DoubleToInt64() public static method

public static DoubleToInt64 ( double val ) : System.Int64
val double
return System.Int64
        internal object exec(string input)
        {
            Match match = null;

            if (!this.globalInt)
            {
                match = this.regex.Match(input);
            }
            else
            {
                int startat = (int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(this.lastIndexInt));
                if (startat <= 0)
                {
                    match = this.regex.Match(input);
                }
                else if (startat <= input.Length)
                {
                    match = this.regex.Match(input, startat);
                }
            }
            if ((match == null) || !match.Success)
            {
                this.lastIndexInt = 0;
                return(DBNull.Value);
            }
            this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
            return(new RegExpMatch(this.regExpConst.arrayPrototype, this.regex, match, input));
        }
 public int Compare(Object x, Object y)
 {
     if (x == null || x is Missing)
     {
         if (y == null || y is Missing)
         {
             return(0);
         }
         else
         {
             return(1);
         }
     }
     else if (y == null || y is Missing)
     {
         return(-1);
     }
     if (this.compareFn != null)
     {
         double result = Convert.ToNumber(this.compareFn.Call(new Object[] { x, y }, null));
         if (result != result)
         {
             throw new JScriptException(JSError.NumberExpected);
         }
         return((int)Runtime.DoubleToInt64(result));
     }
     else
     {
         return(String.CompareOrdinal(Convert.ToString(x), Convert.ToString(y)));
     }
 }
        internal bool test(string input)
        {
            Match match = null;

            if (!this.globalInt)
            {
                match = this.regex.Match(input);
            }
            else
            {
                int startat = (int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(this.lastIndexInt));
                if (startat <= 0)
                {
                    match = this.regex.Match(input);
                }
                else if (startat <= input.Length)
                {
                    match = this.regex.Match(input, startat);
                }
            }
            if ((match == null) || !match.Success)
            {
                this.lastIndexInt = 0;
                return(false);
            }
            this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
            return(true);
        }
        internal bool test(String input)
        {
            Match match = null;

            if (!this.globalInt)
            {
                match = this.regex.Match(input);
            }
            else
            {
                int lastIndex = (int)Runtime.DoubleToInt64(Convert.ToInteger(this.lastIndexInt));
                if (lastIndex <= 0)
                {
                    match = this.regex.Match(input);
                }
                else if (lastIndex <= input.Length)
                {
                    match = this.regex.Match(input, lastIndex);
                }
            }
            if (match == null || !match.Success)
            {
                this.lastIndexInt = 0;
                return(false);
            }
            this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
            return(true);
        }
        internal Object exec(String input)
        {
            Match match = null;

            if (!this.globalInt)
            {
                match = this.regex.Match(input);
            }
            else
            {
                int lastIndex = (int)Runtime.DoubleToInt64(Convert.ToInteger(this.lastIndexInt));
                if (lastIndex <= 0)
                {
                    match = this.regex.Match(input);
                }
                else if (lastIndex <= input.Length)
                {
                    match = this.regex.Match(input, lastIndex);
                }
            }
            if (match == null || !match.Success)
            {
                this.lastIndexInt = 0;
                return(DBNull.Value);
            }
            this.lastIndexInt = this.regExpConst.UpdateConstructor(this.regex, match, input);
            return(new RegExpMatch(this.regExpConst.arrayPrototype, this.regex, match, input));
        }
        public static object DoOp(object v1, object v2)
        {
            IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(v1);
            IConvertible ic           = Microsoft.JScript.Convert.GetIConvertible(v2);

            v1 = Microsoft.JScript.Convert.ToPrimitive(v1, PreferredType.Either, ref iConvertible);
            v2 = Microsoft.JScript.Convert.ToPrimitive(v2, PreferredType.Either, ref ic);
            TypeCode typeCode = Microsoft.JScript.Convert.GetTypeCode(v1, iConvertible);
            TypeCode tc       = Microsoft.JScript.Convert.GetTypeCode(v2, ic);

            if (typeCode == TypeCode.String)
            {
                if (v1 is ConcatString)
                {
                    return(new ConcatString((ConcatString)v1, Microsoft.JScript.Convert.ToString(v2, ic)));
                }
                return(new ConcatString(iConvertible.ToString(null), Microsoft.JScript.Convert.ToString(v2, ic)));
            }
            if (tc == TypeCode.String)
            {
                return(Microsoft.JScript.Convert.ToString(v1, iConvertible) + ic.ToString(null));
            }
            if ((typeCode == TypeCode.Char) && (tc == TypeCode.Char))
            {
                return(iConvertible.ToString(null) + ic.ToString(null));
            }
            if (((typeCode != TypeCode.Char) || (!Microsoft.JScript.Convert.IsPrimitiveNumericTypeCode(tc) && (tc != TypeCode.Boolean))) && ((tc != TypeCode.Char) || (!Microsoft.JScript.Convert.IsPrimitiveNumericTypeCode(typeCode) && (typeCode != TypeCode.Boolean))))
            {
                return(Microsoft.JScript.Convert.ToNumber(v1, iConvertible) + Microsoft.JScript.Convert.ToNumber(v2, ic));
            }
            return((char)((int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToNumber(v1, iConvertible) + Microsoft.JScript.Convert.ToNumber(v2, ic))));
        }
        private int Compare(object x, object y)
        {
            if ((x == null) || (x is Missing))
            {
                if ((y != null) && !(y is Missing))
                {
                    return(1);
                }
                return(0);
            }
            if ((y == null) || (y is Missing))
            {
                return(-1);
            }
            if (this.compareFn == null)
            {
                return(string.CompareOrdinal(Microsoft.JScript.Convert.ToString(x), Microsoft.JScript.Convert.ToString(y)));
            }
            double val = Microsoft.JScript.Convert.ToNumber(this.compareFn.Call(new object[] { x, y }, null));

            if (val != val)
            {
                throw new JScriptException(JSError.NumberExpected);
            }
            return((int)Runtime.DoubleToInt64(val));
        }
        public static ArrayObject slice(Object thisob, VsaEngine engine, double start, Object end)
        {
            ArrayObject array  = engine.GetOriginalArrayConstructor().Construct();
            uint        length = Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
            // compute the start index
            long startIndex = Runtime.DoubleToInt64(Convert.ToInteger(start));

            if (startIndex < 0)
            {
                startIndex = length + startIndex;
                if (startIndex < 0)
                {
                    startIndex = 0;
                }
            }
            else if (startIndex > length)
            {
                startIndex = length;
            }
            // compute the end index
            long endIndex = length;

            if (end != null && !(end is Missing))
            {
                endIndex = Runtime.DoubleToInt64(Convert.ToInteger(end));
                if (endIndex < 0)
                {
                    endIndex = length + endIndex;
                    if (endIndex < 0)
                    {
                        endIndex = 0;
                    }
                }
                else if (endIndex > length)
                {
                    endIndex = length;
                }
            }
            // slice
            if (endIndex > startIndex)
            {
                array.length = endIndex - startIndex;
                for (ulong i = (ulong)startIndex, j = 0; i < (ulong)endIndex; i++, j++)
                {
                    Object val = LateBinding.GetValueAtIndex(thisob, i);
                    if (!(val is Missing))
                    {
                        LateBinding.SetValueAtIndex(array, j, val);
                    }
                }
            }
            return(array);
        }
        public static ArrayObject slice(object thisob, VsaEngine engine, double start, object end)
        {
            ArrayObject obj2 = engine.GetOriginalArrayConstructor().Construct();
            uint        num  = Microsoft.JScript.Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
            long        num2 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(start));

            if (num2 < 0L)
            {
                num2 = num + num2;
                if (num2 < 0L)
                {
                    num2 = 0L;
                }
            }
            else if (num2 > num)
            {
                num2 = num;
            }
            long num3 = num;

            if ((end != null) && !(end is Missing))
            {
                num3 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(end));
                if (num3 < 0L)
                {
                    num3 = num + num3;
                    if (num3 < 0L)
                    {
                        num3 = 0L;
                    }
                }
                else if (num3 > num)
                {
                    num3 = num;
                }
            }
            if (num3 > num2)
            {
                obj2.length = num3 - num2;
                ulong index = (ulong)num2;
                for (ulong i = 0L; index < num3; i += (ulong)1L)
                {
                    object valueAtIndex = LateBinding.GetValueAtIndex(thisob, index);
                    if (!(valueAtIndex is Missing))
                    {
                        LateBinding.SetValueAtIndex(obj2, i, valueAtIndex);
                    }
                    index += (ulong)1L;
                }
            }
            return(obj2);
        }
        public new DateObject CreateInstance(params Object[] args)
        {
            if (args.Length == 0)
            {
                return(new DateObject(this.originalPrototype, DateTime.Now.ToUniversalTime().Ticks / DatePrototype.ticksPerMillisecond - DatePrototype.msTo1970));
            }
            if (args.Length == 1)
            {
                Object       arg0  = args[0];
                IConvertible ic    = Convert.GetIConvertible(arg0);
                TypeCode     tcode = Convert.GetTypeCode(arg0, ic);
                if (tcode == TypeCode.DateTime)
                {
                    return(new DateObject(this.originalPrototype, ic.ToDateTime(null).ToUniversalTime().Ticks / DatePrototype.ticksPerMillisecond - DatePrototype.msTo1970));
                }
                Object yv = Convert.ToPrimitive(arg0, PreferredType.Either, ref ic);
                if (Convert.GetTypeCode(yv, ic) == TypeCode.String)
                {
                    return(new DateObject(this.originalPrototype, parse(ic.ToString(null))));
                }
                double d = Convert.ToNumber(yv, ic);
                if (DatePrototype.minDate <= d && d <= DatePrototype.maxDate)
                {
                    return(new DateObject(this.originalPrototype, d));
                }
                return(new DateObject(this.originalPrototype, Double.NaN));
            }
            double dyear    = Convert.ToNumber(args[0]);
            double dmonth   = Convert.ToNumber(args[1]);
            double ddate    = (args.Length > 2) ? Convert.ToNumber(args[2]) : 1;
            double dhours   = (args.Length > 3) ? Convert.ToNumber(args[3]) : 0;
            double dminutes = (args.Length > 4) ? Convert.ToNumber(args[4]) : 0;
            double dseconds = (args.Length > 5) ? Convert.ToNumber(args[5]) : 0;
            double dms      = (args.Length > 6) ? Convert.ToNumber(args[6]) : 0;
            int    y        = (int)Runtime.DoubleToInt64(dyear);

            if (!Double.IsNaN(dyear) && 0 <= y && y <= 99)
            {
                dyear = y + 1900;
            }
            double day  = DatePrototype.MakeDay(dyear, dmonth, ddate);
            double time = DatePrototype.MakeTime(dhours, dminutes, dseconds, dms);

            return(new DateObject(this.originalPrototype, DatePrototype.TimeClip(DatePrototype.UTC(DatePrototype.MakeDate(day, time)))));
        }
        public DateObject CreateInstance(params object[] args)
        {
            if (args.Length == 0)
            {
                return(new DateObject(this.originalPrototype, (((double)DateTime.Now.ToUniversalTime().Ticks) / 10000.0) - 62135596800000));
            }
            if (args.Length == 1)
            {
                object       ob           = args[0];
                IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(ob);
                if (Microsoft.JScript.Convert.GetTypeCode(ob, iConvertible) == TypeCode.DateTime)
                {
                    return(new DateObject(this.originalPrototype, (((double)iConvertible.ToDateTime(null).ToUniversalTime().Ticks) / 10000.0) - 62135596800000));
                }
                object obj3 = Microsoft.JScript.Convert.ToPrimitive(ob, PreferredType.Either, ref iConvertible);
                if (Microsoft.JScript.Convert.GetTypeCode(obj3, iConvertible) == TypeCode.String)
                {
                    return(new DateObject(this.originalPrototype, parse(iConvertible.ToString(null))));
                }
                double num = Microsoft.JScript.Convert.ToNumber(obj3, iConvertible);
                if ((-8.64E+15 <= num) && (num <= 8.64E+15))
                {
                    return(new DateObject(this.originalPrototype, num));
                }
                return(new DateObject(this.originalPrototype, double.NaN));
            }
            double val   = Microsoft.JScript.Convert.ToNumber(args[0]);
            double month = Microsoft.JScript.Convert.ToNumber(args[1]);
            double date  = (args.Length > 2) ? Microsoft.JScript.Convert.ToNumber(args[2]) : 1.0;
            double hour  = (args.Length > 3) ? Microsoft.JScript.Convert.ToNumber(args[3]) : 0.0;
            double min   = (args.Length > 4) ? Microsoft.JScript.Convert.ToNumber(args[4]) : 0.0;
            double sec   = (args.Length > 5) ? Microsoft.JScript.Convert.ToNumber(args[5]) : 0.0;
            double ms    = (args.Length > 6) ? Microsoft.JScript.Convert.ToNumber(args[6]) : 0.0;
            int    num9  = (int)Runtime.DoubleToInt64(val);

            if ((!double.IsNaN(val) && (0 <= num9)) && (num9 <= 0x63))
            {
                val = num9 + 0x76c;
            }
            double day  = DatePrototype.MakeDay(val, month, date);
            double time = DatePrototype.MakeTime(hour, min, sec, ms);

            return(new DateObject(this.originalPrototype, DatePrototype.TimeClip(DatePrototype.UTC(DatePrototype.MakeDate(day, time)))));
        }
        public static Object DoOp(Object v1, Object v2)
        {
            IConvertible ic1 = Convert.GetIConvertible(v1);
            IConvertible ic2 = Convert.GetIConvertible(v2);

            v1 = Convert.ToPrimitive(v1, PreferredType.Either, ref ic1);
            v2 = Convert.ToPrimitive(v2, PreferredType.Either, ref ic2);
            TypeCode t1 = Convert.GetTypeCode(v1, ic1);
            TypeCode t2 = Convert.GetTypeCode(v2, ic2);

            if (t1 == TypeCode.String)
            {
                if (v1 is ConcatString)
                {
                    return(new ConcatString((ConcatString)v1, Convert.ToString(v2, ic2)));
                }
                else
                {
                    return(new ConcatString(ic1.ToString(null), Convert.ToString(v2, ic2)));
                }
            }
            else if (t2 == TypeCode.String)
            {
                return(Convert.ToString(v1, ic1) + ic2.ToString(null));
            }
            else if (t1 == TypeCode.Char && t2 == TypeCode.Char)
            {
                return(ic1.ToString(null) + ic2.ToString(null));
            }
            else if ((t1 == TypeCode.Char && (Convert.IsPrimitiveNumericTypeCode(t2) || t2 == TypeCode.Boolean)) ||
                     (t2 == TypeCode.Char && (Convert.IsPrimitiveNumericTypeCode(t1) || t1 == TypeCode.Boolean)))
            {
                return((char)(int)Runtime.DoubleToInt64(Convert.ToNumber(v1, ic1) + Convert.ToNumber(v2, ic2)));
            }
            else
            {
                return(Convert.ToNumber(v1, ic1) + Convert.ToNumber(v2, ic2));
            }
        }
        public static String substr(Object thisob, double start, Object count)
        {
            String thisStr = thisob as String;

            if (thisStr == null)
            {
                thisStr = Convert.ToString(thisob);
            }
            int    length     = thisStr.Length;
            double startIndex = Convert.ToInteger(start);

            if (startIndex < 0)
            {
                startIndex += length;
            }
            if (startIndex < 0)
            {
                startIndex = 0;
            }
            else if (startIndex > length)
            {
                startIndex = length;
            }
            int nChars = count is int?(int)count:
                         ((count == null || count is Missing) ? length - (int)Runtime.DoubleToInt64(startIndex) : (int)Runtime.DoubleToInt64(Convert.ToInteger(count)));

            if (startIndex + nChars > length)
            {
                nChars = length - (int)startIndex;
            }
            if (nChars <= 0)
            {
                return("");
            }
            else
            {
                return(thisStr.Substring((int)startIndex, nChars));
            }
        }
        public static double UTC(object year, object month, object date, object hours, object minutes, object seconds, object ms)
        {
            if (year is Missing)
            {
                return((((double)DateTime.Now.ToUniversalTime().Ticks) / 10000.0) - 62135596800000);
            }
            double val  = Microsoft.JScript.Convert.ToNumber(year);
            double num2 = (month is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(month);
            double num3 = (date is Missing) ? 1.0 : Microsoft.JScript.Convert.ToNumber(date);
            double hour = (hours is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(hours);
            double min  = (minutes is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(minutes);
            double sec  = (seconds is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(seconds);
            double num7 = (ms is Missing) ? 0.0 : Microsoft.JScript.Convert.ToNumber(ms);
            int    num8 = (int)Runtime.DoubleToInt64(val);

            if ((!double.IsNaN(val) && (0 <= num8)) && (num8 <= 0x63))
            {
                val = num8 + 0x76c;
            }
            double day  = DatePrototype.MakeDay(val, num2, num3);
            double time = DatePrototype.MakeTime(hour, min, sec, num7);

            return(DatePrototype.TimeClip(DatePrototype.MakeDate(day, time)));
        }
        public static double UTC(Object year, Object month, Object date, Object hours, Object minutes, Object seconds, Object ms)
        {
            if (year is Missing)
            {
                return(DateTime.Now.ToUniversalTime().Ticks / DatePrototype.ticksPerMillisecond - DatePrototype.msTo1970);
            }
            double dyear    = Convert.ToNumber(year);
            double dmonth   = month   is Missing ? 0 : Convert.ToNumber(month);
            double ddate    = date    is Missing ? 1 : Convert.ToNumber(date);
            double dhours   = hours   is Missing ? 0 : Convert.ToNumber(hours);
            double dminutes = minutes is Missing ? 0 : Convert.ToNumber(minutes);
            double dseconds = seconds is Missing ? 0 : Convert.ToNumber(seconds);
            double dms      = ms      is Missing ? 0 : Convert.ToNumber(ms);
            int    y        = (int)Runtime.DoubleToInt64(dyear);

            if (!Double.IsNaN(dyear) && 0 <= y && y <= 99)
            {
                dyear = y + 1900;
            }
            double day  = DatePrototype.MakeDay(dyear, dmonth, ddate);
            double time = DatePrototype.MakeTime(dhours, dminutes, dseconds, dms);

            return(DatePrototype.TimeClip(DatePrototype.MakeDate(day, time)));
        }
        private object EvaluateBitwiseBinary(object v1, object v2, JSToken operatorTok)
        {
            int          num;
            IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(v1);
            IConvertible ic           = Microsoft.JScript.Convert.GetIConvertible(v2);
            TypeCode     typeCode     = Microsoft.JScript.Convert.GetTypeCode(v1, iConvertible);
            TypeCode     code2        = Microsoft.JScript.Convert.GetTypeCode(v2, ic);

            switch (typeCode)
            {
            case TypeCode.Empty:
            case TypeCode.DBNull:
                return(this.EvaluateBitwiseBinary(0, v2, operatorTok));

            case TypeCode.Boolean:
            case TypeCode.Char:
            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
                num = iConvertible.ToInt32(null);
                switch (code2)
                {
                case TypeCode.Empty:
                case TypeCode.DBNull:
                    return(DoOp(num, 0, operatorTok));

                case TypeCode.Boolean:
                case TypeCode.Char:
                case TypeCode.SByte:
                case TypeCode.Byte:
                case TypeCode.Int16:
                case TypeCode.UInt16:
                case TypeCode.Int32:
                    return(DoOp(num, ic.ToInt32(null), operatorTok));

                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                    return(DoOp(num, (int)Runtime.DoubleToInt64(ic.ToDouble(null)), operatorTok));
                }
                break;

            case TypeCode.UInt32:
            case TypeCode.Int64:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
                num = (int)Runtime.DoubleToInt64(iConvertible.ToDouble(null));
                switch (code2)
                {
                case TypeCode.Empty:
                case TypeCode.DBNull:
                    return(DoOp(num, 0, operatorTok));

                case TypeCode.Boolean:
                case TypeCode.Char:
                case TypeCode.SByte:
                case TypeCode.Byte:
                case TypeCode.Int16:
                case TypeCode.UInt16:
                case TypeCode.Int32:
                    return(DoOp(num, ic.ToInt32(null), operatorTok));

                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                    return(DoOp(num, (int)Runtime.DoubleToInt64(ic.ToDouble(null)), operatorTok));
                }
                break;
            }
            if (v2 == null)
            {
                return(DoOp(Microsoft.JScript.Convert.ToInt32(v1), 0, base.operatorTok));
            }
            MethodInfo @operator = base.GetOperator(v1.GetType(), v2.GetType());

            if (@operator != null)
            {
                return(@operator.Invoke(null, BindingFlags.Default, JSBinder.ob, new object[] { v1, v2 }, null));
            }
            return(DoOp(Microsoft.JScript.Convert.ToInt32(v1), Microsoft.JScript.Convert.ToInt32(v2), base.operatorTok));
        }
        private void TranslateToIL(ILGenerator il, Object val, Type rtype)
        {
            IConvertible ic = Convert.GetIConvertible(val);

            switch (Convert.GetTypeCode(val, ic))
            {
            case TypeCode.Empty:
                il.Emit(OpCodes.Ldnull);
                if (rtype.IsValueType)
                {
                    Convert.Emit(this, il, Typeob.Object, rtype);
                }
                return;

            case TypeCode.Object:
                break;

            case TypeCode.DBNull:
                il.Emit(OpCodes.Ldsfld, Typeob.Null.GetField("Value"));
                Convert.Emit(this, il, Typeob.Null, rtype);
                return;

            case TypeCode.Boolean:
                ConstantWrapper.TranslateToILInt(il, ic.ToInt32(null));
                Convert.Emit(this, il, Typeob.Boolean, rtype);
                return;

            case TypeCode.Char:
            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
                ConstantWrapper.TranslateToILInt(il, ic.ToInt32(null));
                if (rtype.IsEnum)
                {
                    return;
                }
                if (val is EnumWrapper)
                {
                    Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                }
                else
                {
                    Convert.Emit(this, il, Globals.TypeRefs.ToReferenceContext(val.GetType()), rtype);
                }
                return;

            case TypeCode.UInt32:
                ConstantWrapper.TranslateToILInt(il, (int)ic.ToUInt32(null));
                if (rtype.IsEnum)
                {
                    return;
                }
                if (val is EnumWrapper)
                {
                    Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                }
                else
                {
                    Convert.Emit(this, il, Typeob.UInt32, rtype);
                }
                return;

            case TypeCode.Int64:
                long l = ic.ToInt64(null);
                if (Int32.MinValue <= l && l <= Int32.MaxValue)
                {
                    ConstantWrapper.TranslateToILInt(il, (int)l);
                    il.Emit(OpCodes.Conv_I8);
                }
                else
                {
                    il.Emit(OpCodes.Ldc_I8, l);
                }
                if (rtype.IsEnum)
                {
                    return;
                }
                if (val is EnumWrapper)
                {
                    Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                }
                else
                {
                    Convert.Emit(this, il, Typeob.Int64, rtype);
                }
                return;

            case TypeCode.UInt64:
                ulong ul = ic.ToUInt64(null);
                if (ul <= Int32.MaxValue)
                {
                    ConstantWrapper.TranslateToILInt(il, (int)ul);
                    il.Emit(OpCodes.Conv_I8);
                }
                else
                {
                    il.Emit(OpCodes.Ldc_I8, (long)ul);
                }
                if (rtype.IsEnum)
                {
                    return;
                }
                if (val is EnumWrapper)
                {
                    Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                }
                else
                {
                    Convert.Emit(this, il, Typeob.UInt64, rtype);
                }
                return;

            case TypeCode.Single:
                float f = ic.ToSingle(null);
                if (f == f && (f != 0 || !Single.IsNegativeInfinity(1 / f)))
                {
                    int i = (int)Runtime.DoubleToInt64(f);
                    if (-128 <= i && i <= 127 && f == (float)i)
                    {
                        ConstantWrapper.TranslateToILInt(il, i);
                        il.Emit(OpCodes.Conv_R4);
                    }
                    else
                    {
                        il.Emit(OpCodes.Ldc_R4, f);
                    }
                }
                else
                {
                    il.Emit(OpCodes.Ldc_R4, f);
                }
                Convert.Emit(this, il, Typeob.Single, rtype);
                return;

            case TypeCode.Double:
                double d = ic.ToDouble(null);
                if (d == d && (d != 0 || !Double.IsNegativeInfinity(1 / d)))
                {
                    int i = (int)Runtime.DoubleToInt64(d);
                    if (-128 <= i && i <= 127 && d == (double)i)
                    {
                        ConstantWrapper.TranslateToILInt(il, i);
                        il.Emit(OpCodes.Conv_R8);
                    }
                    else
                    {
                        il.Emit(OpCodes.Ldc_R8, d);
                    }
                }
                else
                {
                    il.Emit(OpCodes.Ldc_R8, d);
                }
                Convert.Emit(this, il, Typeob.Double, rtype);
                return;

            case TypeCode.Decimal:
                int[] bits = Decimal.GetBits(ic.ToDecimal(null));
                ConstantWrapper.TranslateToILInt(il, bits[0]);
                ConstantWrapper.TranslateToILInt(il, bits[1]);
                ConstantWrapper.TranslateToILInt(il, bits[2]);
                il.Emit(bits[3] < 0 ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0); //bool isNegative
                ConstantWrapper.TranslateToILInt(il, (bits[3] & 0x7FFFFFFF) >> 16);
                il.Emit(OpCodes.Newobj, CompilerGlobals.decimalConstructor);
                Convert.Emit(this, il, Typeob.Decimal, rtype);
                return;

            case TypeCode.DateTime:
                l = ic.ToDateTime(null).Ticks;
                il.Emit(OpCodes.Ldc_I8, l);
                Convert.Emit(this, il, Typeob.Int64, rtype);
                return;

            case TypeCode.String:
                String str = ic.ToString(null);
                if (rtype == Typeob.Char && str.Length == 1)
                {
                    ConstantWrapper.TranslateToILInt(il, (int)str[0]);
                    return;
                }
                il.Emit(OpCodes.Ldstr, str);
                Convert.Emit(this, il, Typeob.String, rtype);
                return;
            }
            if (val is Enum)
            {
                if (rtype == Typeob.String)
                {
                    this.TranslateToIL(il, val.ToString(), rtype);
                }
                else if (rtype.IsPrimitive)
                {
                    this.TranslateToIL(il, System.Convert.ChangeType(val, Enum.GetUnderlyingType(Globals.TypeRefs.ToReferenceContext(val.GetType())), CultureInfo.InvariantCulture), rtype);
                }
                else
                {
                    Type et = Globals.TypeRefs.ToReferenceContext(val.GetType());
                    Type ut = Enum.GetUnderlyingType(et);
                    this.TranslateToIL(il, System.Convert.ChangeType(val, ut, CultureInfo.InvariantCulture), ut);
                    il.Emit(OpCodes.Box, et);
                    Convert.Emit(this, il, Typeob.Object, rtype);
                }
                return;
            }
            if (val is EnumWrapper)
            {
                if (rtype == Typeob.String)
                {
                    this.TranslateToIL(il, val.ToString(), rtype);
                }
                else if (rtype.IsPrimitive)
                {
                    this.TranslateToIL(il, ((EnumWrapper)val).ToNumericValue(), rtype);
                }
                else
                {
                    Type et = ((EnumWrapper)val).type;
                    Type ut = Globals.TypeRefs.ToReferenceContext(((EnumWrapper)val).value.GetType());
                    this.TranslateToIL(il, ((EnumWrapper)val).value, ut);
                    il.Emit(OpCodes.Box, et);
                    Convert.Emit(this, il, Typeob.Object, rtype);
                }
                return;
            }
            if (val is Type)
            {
                il.Emit(OpCodes.Ldtoken, (Type)val);
                il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
                Convert.Emit(this, il, Typeob.Type, rtype);
            }
            else if (val is Namespace)
            {
                il.Emit(OpCodes.Ldstr, ((Namespace)val).Name);
                this.EmitILToLoadEngine(il);
                il.Emit(OpCodes.Call, CompilerGlobals.getNamespaceMethod);
                Convert.Emit(this, il, Typeob.Namespace, rtype);
            }
            else if (val is ClassScope)
            {
                il.Emit(OpCodes.Ldtoken, ((ClassScope)val).GetTypeBuilderOrEnumBuilder());
                il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
                Convert.Emit(this, il, Typeob.Type, rtype);
            }
            else if (val is TypedArray)
            {
                il.Emit(OpCodes.Ldtoken, Convert.ToType((TypedArray)val));
                il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
                Convert.Emit(this, il, Typeob.Type, rtype);
            }
            else if (val is NumberObject)
            {
                this.TranslateToIL(il, ((NumberObject)val).value, Typeob.Object);
                this.EmitILToLoadEngine(il);
                il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
                Convert.Emit(this, il, Typeob.NumberObject, rtype);
            }
            else if (val is StringObject)
            {
                il.Emit(OpCodes.Ldstr, ((StringObject)val).value);
                this.EmitILToLoadEngine(il);
                il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
                Convert.Emit(this, il, Typeob.StringObject, rtype);
            }
            else if (val is BooleanObject)
            {
                il.Emit(((BooleanObject)val).value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
                il.Emit(OpCodes.Box, Typeob.Boolean);
                this.EmitILToLoadEngine(il);
                il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
                Convert.Emit(this, il, Typeob.BooleanObject, rtype);
            }
            else if (val is ActiveXObjectConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ActiveXObject").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is ArrayConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Array").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is BooleanConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Boolean").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is DateConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Date").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is EnumeratorConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Enumerator").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is ErrorConstructor)
            {
                ErrorConstructor error = (ErrorConstructor)val;
                if (error == ErrorConstructor.evalOb)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("EvalError").GetGetMethod());
                }
                else if (error == ErrorConstructor.rangeOb)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RangeError").GetGetMethod());
                }
                else if (error == ErrorConstructor.referenceOb)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ReferenceError").GetGetMethod());
                }
                else if (error == ErrorConstructor.syntaxOb)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("SyntaxError").GetGetMethod());
                }
                else if (error == ErrorConstructor.typeOb)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("TypeError").GetGetMethod());
                }
                else if (error == ErrorConstructor.uriOb)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("URIError").GetGetMethod());
                }
                else
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Error").GetGetMethod());
                }
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is FunctionConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Function").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is MathObject)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Math").GetGetMethod());
                Convert.Emit(this, il, Typeob.JSObject, rtype);
            }
            else if (val is NumberConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Number").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is ObjectConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Object").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is RegExpConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RegExp").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is StringConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("String").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is VBArrayConstructor)
            {
                il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("VBArray").GetGetMethod());
                Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
            }
            else if (val is IntPtr)
            {
                il.Emit(OpCodes.Ldc_I8, (long)(IntPtr)val);
                il.Emit(OpCodes.Conv_I);
                Convert.Emit(this, il, Typeob.IntPtr, rtype);
            }
            else if (val is UIntPtr)
            {
                il.Emit(OpCodes.Ldc_I8, (long)(UIntPtr)val);
                il.Emit(OpCodes.Conv_U);
                Convert.Emit(this, il, Typeob.UIntPtr, rtype);
            }
            else if (val is Missing)
            {
                il.Emit(OpCodes.Ldsfld, CompilerGlobals.missingField);
                Convert.Emit(this, il, Typeob.Object, rtype);
            }
            else if (val is System.Reflection.Missing)
            {
                if (rtype.IsPrimitive)
                {
                    this.TranslateToIL(il, Double.NaN, rtype);
                }
                else if (rtype != Typeob.Object && !rtype.IsValueType)
                {
                    il.Emit(OpCodes.Ldnull);
                }
                else
                {
                    il.Emit(OpCodes.Ldsfld, CompilerGlobals.systemReflectionMissingField);
                    Convert.Emit(this, il, Typeob.Object, rtype);
                }
            }
            else if (val != this.value) //Value was coerced to some type we have no compile time knowlegde of
            {
                this.TranslateToIL(il, this.value, rtype);
            }
            else
            {
                throw new JScriptException(JSError.InternalError, this.context); //It should not be possible to wrap any other kind of object
            }
        }
        public object EvaluateUnary(object v)
        {
            IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(v);

            switch (Microsoft.JScript.Convert.GetTypeCode(v, iConvertible))
            {
            case TypeCode.Empty:
                return(this.EvaluateUnary((double)1.0 / (double)0.0));

            case TypeCode.DBNull:
                return(this.EvaluateUnary(0));

            case TypeCode.Boolean:
                return(this.EvaluateUnary(iConvertible.ToBoolean(null) ? 1 : 0));

            case TypeCode.Char:
                return(this.EvaluateUnary((int)iConvertible.ToChar(null)));

            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
            {
                int num = iConvertible.ToInt32(null);
                switch (this.operatorTok)
                {
                case JSToken.FirstOp:
                    return(num == 0);

                case JSToken.BitwiseNot:
                    return(~num);

                case JSToken.FirstBinaryOp:
                    return(num);

                case JSToken.Minus:
                    switch (num)
                    {
                    case 0:
                        return(-((double)num));

                    case -2147483648:
                        return((ulong)-((double)num));
                    }
                    return(-num);
                }
                throw new JScriptException(JSError.InternalError, base.context);
            }

            case TypeCode.UInt32:
            {
                uint num2 = iConvertible.ToUInt32(null);
                switch (this.operatorTok)
                {
                case JSToken.FirstOp:
                    return(num2 == 0);

                case JSToken.BitwiseNot:
                    return(~num2);

                case JSToken.FirstBinaryOp:
                    return(num2);

                case JSToken.Minus:
                    if ((num2 != 0) && (num2 <= 0x7fffffff))
                    {
                        return((int)-num2);
                    }
                    return(-((double)num2));
                }
                throw new JScriptException(JSError.InternalError, base.context);
            }

            case TypeCode.Int64:
            {
                long num3 = iConvertible.ToInt64(null);
                switch (this.operatorTok)
                {
                case JSToken.FirstOp:
                    return(num3 == 0L);

                case JSToken.BitwiseNot:
                    return(~num3);

                case JSToken.FirstBinaryOp:
                    return(num3);

                case JSToken.Minus:
                    if ((num3 != 0L) && (num3 != -9223372036854775808L))
                    {
                        return(-num3);
                    }
                    return(-((double)num3));
                }
                throw new JScriptException(JSError.InternalError, base.context);
            }

            case TypeCode.UInt64:
            {
                ulong num4 = iConvertible.ToUInt64(null);
                switch (this.operatorTok)
                {
                case JSToken.FirstOp:
                    return(num4 == 0L);

                case JSToken.BitwiseNot:
                    return(~num4);

                case JSToken.FirstBinaryOp:
                    return(num4);

                case JSToken.Minus:
                    if ((num4 != 0L) && (num4 <= 0x7fffffffffffffffL))
                    {
                        return((long)-num4);
                    }
                    return(-((double)num4));
                }
                throw new JScriptException(JSError.InternalError, base.context);
            }

            case TypeCode.Single:
            case TypeCode.Double:
            {
                double d = iConvertible.ToDouble(null);
                switch (this.operatorTok)
                {
                case JSToken.FirstOp:
                    return(!Microsoft.JScript.Convert.ToBoolean(d));

                case JSToken.BitwiseNot:
                    return(~((int)Runtime.DoubleToInt64(d)));

                case JSToken.FirstBinaryOp:
                    return(d);

                case JSToken.Minus:
                    return(-d);
                }
                throw new JScriptException(JSError.InternalError, base.context);
            }

            case TypeCode.String:
                break;

            default:
            {
                MethodInfo @operator = this.GetOperator(v.GetType());
                if (@operator != null)
                {
                    return(@operator.Invoke(null, BindingFlags.Default, JSBinder.ob, new object[] { v }, null));
                }
                break;
            }
            }
            switch (this.operatorTok)
            {
            case JSToken.FirstOp:
                return(!Microsoft.JScript.Convert.ToBoolean(v, iConvertible));

            case JSToken.BitwiseNot:
                return(~Microsoft.JScript.Convert.ToInt32(v, iConvertible));

            case JSToken.FirstBinaryOp:
                return(Microsoft.JScript.Convert.ToNumber(v, iConvertible));

            case JSToken.Minus:
                return(-Microsoft.JScript.Convert.ToNumber(v, iConvertible));
            }
            throw new JScriptException(JSError.InternalError, base.context);
        }
        public static ArrayObject splice(Object thisob, VsaEngine engine, double start, double deleteCnt, params Object[] args)
        {
            uint oldLength = Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
            // compute the start index
            long startIndex = Runtime.DoubleToInt64(Convert.ToInteger(start));

            if (startIndex < 0)
            {
                startIndex = oldLength + startIndex;
                if (startIndex < 0)
                {
                    startIndex = 0;
                }
            }
            else if (startIndex > oldLength)
            {
                startIndex = oldLength;
            }

            // compute the number of items to delete
            long deleteCount = Runtime.DoubleToInt64(Convert.ToInteger(deleteCnt));

            if (deleteCount < 0)
            {
                deleteCount = 0;
            }
            else if (deleteCount > oldLength - startIndex)
            {
                deleteCount = oldLength - startIndex;
            }
            long newLength = oldLength + args.Length - deleteCount;

            // create an array for the result
            ArrayObject result = engine.GetOriginalArrayConstructor().Construct();

            result.length = deleteCount;

            // special case array objects (nice speedup if dense)
            if (thisob is ArrayObject)
            {
                ((ArrayObject)thisob).Splice((uint)startIndex, (uint)deleteCount, args, result, (uint)oldLength, (uint)newLength);
                return(result);
            }

            // copy the deleted items to the result array
            for (ulong i = 0; i < (ulong)deleteCount; i++)
            {
                result.SetValueAtIndex((uint)i, LateBinding.GetValueAtIndex(thisob, i + (ulong)startIndex));
            }

            // shift the remaining elements left or right
            long n = oldLength - startIndex - deleteCount;

            if (newLength < oldLength)
            {
                for (long i = 0; i < n; i++)
                {
                    LateBinding.SetValueAtIndex(thisob, (ulong)(i + startIndex + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)(i + startIndex + deleteCount)));
                }
                LateBinding.SetMemberValue(thisob, "length", newLength);
            }
            else
            {
                LateBinding.SetMemberValue(thisob, "length", newLength);
                for (long i = n - 1; i >= 0; i--)
                {
                    LateBinding.SetValueAtIndex(thisob, (ulong)(i + startIndex + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)(i + startIndex + deleteCount)));
                }
            }

            // splice in the arguments
            int m = args == null ? 0 : args.Length;

            for (uint i = 0; i < m; i++)
            {
                LateBinding.SetValueAtIndex(thisob, i + (ulong)startIndex, args[i]);
            }

            return(result);
        }
        private Object EvaluateBitwiseBinary(Object v1, Object v2, JSToken operatorTok)
        {
            IConvertible ic1 = Convert.GetIConvertible(v1);
            IConvertible ic2 = Convert.GetIConvertible(v2);
            TypeCode     t1  = Convert.GetTypeCode(v1, ic1);
            TypeCode     t2  = Convert.GetTypeCode(v2, ic2);

            switch (t1)
            {
            case TypeCode.Empty:
            case TypeCode.DBNull:
                return(EvaluateBitwiseBinary(0, v2, operatorTok));

            case TypeCode.Boolean:
            case TypeCode.Char:
            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
                int i = ic1.ToInt32(null);
                switch (t2)
                {
                case TypeCode.Empty:
                case TypeCode.DBNull:
                    return(DoOp(i, 0, operatorTok));

                case TypeCode.Boolean:
                case TypeCode.Char:
                case TypeCode.SByte:
                case TypeCode.Byte:
                case TypeCode.Int16:
                case TypeCode.UInt16:
                case TypeCode.Int32:
                    return(DoOp(i, ic2.ToInt32(null), operatorTok));

                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                    return(DoOp(i, (int)Runtime.DoubleToInt64(ic2.ToDouble(null)), operatorTok));

                case TypeCode.Object:
                case TypeCode.Decimal:
                case TypeCode.DateTime:
                case TypeCode.String:
                    break;
                }
                break;

            case TypeCode.UInt32:
            case TypeCode.Int64:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
                i = (int)Runtime.DoubleToInt64(ic1.ToDouble(null));
                switch (t2)
                {
                case TypeCode.Empty:
                case TypeCode.DBNull:
                    return(DoOp(i, 0, operatorTok));

                case TypeCode.Boolean:
                case TypeCode.Char:
                case TypeCode.SByte:
                case TypeCode.Byte:
                case TypeCode.Int16:
                case TypeCode.UInt16:
                case TypeCode.Int32:
                    return(DoOp(i, ic2.ToInt32(null), operatorTok));

                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                case TypeCode.Single:
                case TypeCode.Double:
                    return(DoOp(i, (int)Runtime.DoubleToInt64(ic2.ToDouble(null)), operatorTok));

                case TypeCode.Object:
                case TypeCode.Decimal:
                case TypeCode.DateTime:
                case TypeCode.String:
                    break;
                }
                break;

            case TypeCode.Object:
            case TypeCode.Decimal:
            case TypeCode.DateTime:
            case TypeCode.String:
                break;
            }
            if (v2 == null)
            {
                return(DoOp(Convert.ToInt32(v1), 0, this.operatorTok));
            }
            MethodInfo oper = this.GetOperator(v1.GetType(), v2.GetType());

            if (oper != null)
            {
                return(oper.Invoke(null, (BindingFlags)0, JSBinder.ob, new Object[] { v1, v2 }, null));
            }
            else
            {
                return(DoOp(Convert.ToInt32(v1), Convert.ToInt32(v2), this.operatorTok));
            }
        }
Beispiel #21
0
        private void TranslateToIL(ILGenerator il, object val, Type rtype)
        {
            long         ticks;
            IConvertible iConvertible = Microsoft.JScript.Convert.GetIConvertible(val);

            switch (Microsoft.JScript.Convert.GetTypeCode(val, iConvertible))
            {
            case TypeCode.Empty:
                il.Emit(OpCodes.Ldnull);
                if (rtype.IsValueType)
                {
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
                }
                return;

            case TypeCode.DBNull:
                il.Emit(OpCodes.Ldsfld, Typeob.Null.GetField("Value"));
                Microsoft.JScript.Convert.Emit(this, il, Typeob.Null, rtype);
                return;

            case TypeCode.Boolean:
                TranslateToILInt(il, iConvertible.ToInt32(null));
                Microsoft.JScript.Convert.Emit(this, il, Typeob.Boolean, rtype);
                return;

            case TypeCode.Char:
            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
                TranslateToILInt(il, iConvertible.ToInt32(null));
                if (!rtype.IsEnum)
                {
                    if (val is EnumWrapper)
                    {
                        Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                        return;
                    }
                    Microsoft.JScript.Convert.Emit(this, il, Globals.TypeRefs.ToReferenceContext(val.GetType()), rtype);
                    return;
                }
                return;

            case TypeCode.UInt32:
                TranslateToILInt(il, (int)iConvertible.ToUInt32(null));
                if (!rtype.IsEnum)
                {
                    if (val is EnumWrapper)
                    {
                        Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                        return;
                    }
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.UInt32, rtype);
                    return;
                }
                return;

            case TypeCode.Int64:
                ticks = iConvertible.ToInt64(null);
                if ((-2147483648L > ticks) || (ticks > 0x7fffffffL))
                {
                    il.Emit(OpCodes.Ldc_I8, ticks);
                    break;
                }
                TranslateToILInt(il, (int)ticks);
                il.Emit(OpCodes.Conv_I8);
                break;

            case TypeCode.UInt64:
            {
                ulong num2 = iConvertible.ToUInt64(null);
                if (num2 > 0x7fffffffL)
                {
                    il.Emit(OpCodes.Ldc_I8, (long)num2);
                }
                else
                {
                    TranslateToILInt(il, (int)num2);
                    il.Emit(OpCodes.Conv_I8);
                }
                if (!rtype.IsEnum)
                {
                    if (val is EnumWrapper)
                    {
                        Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                        return;
                    }
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.UInt64, rtype);
                }
                return;
            }

            case TypeCode.Single:
            {
                float arg = iConvertible.ToSingle(null);
                if ((arg != arg) || ((arg == 0f) && float.IsNegativeInfinity(1f / arg)))
                {
                    il.Emit(OpCodes.Ldc_R4, arg);
                }
                else
                {
                    int i = (int)Runtime.DoubleToInt64((double)arg);
                    if (((-128 > i) || (i > 0x7f)) || (arg != i))
                    {
                        il.Emit(OpCodes.Ldc_R4, arg);
                    }
                    else
                    {
                        TranslateToILInt(il, i);
                        il.Emit(OpCodes.Conv_R4);
                    }
                }
                Microsoft.JScript.Convert.Emit(this, il, Typeob.Single, rtype);
                return;
            }

            case TypeCode.Double:
            {
                double num5 = iConvertible.ToDouble(null);
                if ((num5 != num5) || ((num5 == 0.0) && double.IsNegativeInfinity(1.0 / num5)))
                {
                    il.Emit(OpCodes.Ldc_R8, num5);
                }
                else
                {
                    int num6 = (int)Runtime.DoubleToInt64(num5);
                    if (((-128 > num6) || (num6 > 0x7f)) || (num5 != num6))
                    {
                        il.Emit(OpCodes.Ldc_R8, num5);
                    }
                    else
                    {
                        TranslateToILInt(il, num6);
                        il.Emit(OpCodes.Conv_R8);
                    }
                }
                Microsoft.JScript.Convert.Emit(this, il, Typeob.Double, rtype);
                return;
            }

            case TypeCode.Decimal:
            {
                int[] bits = decimal.GetBits(iConvertible.ToDecimal(null));
                TranslateToILInt(il, bits[0]);
                TranslateToILInt(il, bits[1]);
                TranslateToILInt(il, bits[2]);
                il.Emit((bits[3] < 0) ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
                TranslateToILInt(il, (bits[3] & 0x7fffffff) >> 0x10);
                il.Emit(OpCodes.Newobj, CompilerGlobals.decimalConstructor);
                Microsoft.JScript.Convert.Emit(this, il, Typeob.Decimal, rtype);
                return;
            }

            case TypeCode.DateTime:
                ticks = iConvertible.ToDateTime(null).Ticks;
                il.Emit(OpCodes.Ldc_I8, ticks);
                Microsoft.JScript.Convert.Emit(this, il, Typeob.Int64, rtype);
                return;

            case TypeCode.String:
            {
                string str = iConvertible.ToString(null);
                if (!(rtype == Typeob.Char) || (str.Length != 1))
                {
                    il.Emit(OpCodes.Ldstr, str);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.String, rtype);
                    return;
                }
                TranslateToILInt(il, str[0]);
                return;
            }

            default:
                if (val is Enum)
                {
                    if (rtype == Typeob.String)
                    {
                        this.TranslateToIL(il, val.ToString(), rtype);
                        return;
                    }
                    if (rtype.IsPrimitive)
                    {
                        this.TranslateToIL(il, System.Convert.ChangeType(val, Enum.GetUnderlyingType(Globals.TypeRefs.ToReferenceContext(val.GetType())), CultureInfo.InvariantCulture), rtype);
                        return;
                    }
                    Type enumType       = Globals.TypeRefs.ToReferenceContext(val.GetType());
                    Type underlyingType = Enum.GetUnderlyingType(enumType);
                    this.TranslateToIL(il, System.Convert.ChangeType(val, underlyingType, CultureInfo.InvariantCulture), underlyingType);
                    il.Emit(OpCodes.Box, enumType);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
                }
                else if (val is EnumWrapper)
                {
                    if (rtype == Typeob.String)
                    {
                        this.TranslateToIL(il, val.ToString(), rtype);
                        return;
                    }
                    if (rtype.IsPrimitive)
                    {
                        this.TranslateToIL(il, ((EnumWrapper)val).ToNumericValue(), rtype);
                    }
                    else
                    {
                        Type type  = ((EnumWrapper)val).type;
                        Type type4 = Globals.TypeRefs.ToReferenceContext(((EnumWrapper)val).value.GetType());
                        this.TranslateToIL(il, ((EnumWrapper)val).value, type4);
                        il.Emit(OpCodes.Box, type);
                        Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
                    }
                }
                else if (val is Type)
                {
                    il.Emit(OpCodes.Ldtoken, (Type)val);
                    il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Type, rtype);
                }
                else if (val is Namespace)
                {
                    il.Emit(OpCodes.Ldstr, ((Namespace)val).Name);
                    base.EmitILToLoadEngine(il);
                    il.Emit(OpCodes.Call, CompilerGlobals.getNamespaceMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Namespace, rtype);
                }
                else if (val is ClassScope)
                {
                    il.Emit(OpCodes.Ldtoken, ((ClassScope)val).GetTypeBuilderOrEnumBuilder());
                    il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Type, rtype);
                }
                else if (val is TypedArray)
                {
                    il.Emit(OpCodes.Ldtoken, Microsoft.JScript.Convert.ToType((TypedArray)val));
                    il.Emit(OpCodes.Call, CompilerGlobals.getTypeFromHandleMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Type, rtype);
                }
                else if (val is NumberObject)
                {
                    this.TranslateToIL(il, ((NumberObject)val).value, Typeob.Object);
                    base.EmitILToLoadEngine(il);
                    il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.NumberObject, rtype);
                }
                else if (val is StringObject)
                {
                    il.Emit(OpCodes.Ldstr, ((StringObject)val).value);
                    base.EmitILToLoadEngine(il);
                    il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.StringObject, rtype);
                }
                else if (val is BooleanObject)
                {
                    il.Emit(((BooleanObject)val).value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
                    il.Emit(OpCodes.Box, Typeob.Boolean);
                    base.EmitILToLoadEngine(il);
                    il.Emit(OpCodes.Call, CompilerGlobals.toObjectMethod);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.BooleanObject, rtype);
                }
                else if (val is ActiveXObjectConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ActiveXObject").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is ArrayConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Array").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is BooleanConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Boolean").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is DateConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Date").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is EnumeratorConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Enumerator").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is ErrorConstructor)
                {
                    ErrorConstructor constructor = (ErrorConstructor)val;
                    if (constructor == ErrorConstructor.evalOb)
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("EvalError").GetGetMethod());
                    }
                    else if (constructor == ErrorConstructor.rangeOb)
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RangeError").GetGetMethod());
                    }
                    else if (constructor == ErrorConstructor.referenceOb)
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("ReferenceError").GetGetMethod());
                    }
                    else if (constructor == ErrorConstructor.syntaxOb)
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("SyntaxError").GetGetMethod());
                    }
                    else if (constructor == ErrorConstructor.typeOb)
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("TypeError").GetGetMethod());
                    }
                    else if (constructor == ErrorConstructor.uriOb)
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("URIError").GetGetMethod());
                    }
                    else
                    {
                        il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Error").GetGetMethod());
                    }
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is FunctionConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Function").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is MathObject)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Math").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.JSObject, rtype);
                }
                else if (val is NumberConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Number").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is ObjectConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("Object").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is RegExpConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("RegExp").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is StringConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("String").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is VBArrayConstructor)
                {
                    il.Emit(OpCodes.Call, Typeob.GlobalObject.GetProperty("VBArray").GetGetMethod());
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.ScriptFunction, rtype);
                }
                else if (val is IntPtr)
                {
                    il.Emit(OpCodes.Ldc_I8, (long)((IntPtr)val));
                    il.Emit(OpCodes.Conv_I);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.IntPtr, rtype);
                }
                else if (val is UIntPtr)
                {
                    il.Emit(OpCodes.Ldc_I8, (long)((ulong)((UIntPtr)val)));
                    il.Emit(OpCodes.Conv_U);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.UIntPtr, rtype);
                }
                else if (val is Microsoft.JScript.Missing)
                {
                    il.Emit(OpCodes.Ldsfld, CompilerGlobals.missingField);
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
                }
                else if (val is System.Reflection.Missing)
                {
                    if (rtype.IsPrimitive)
                    {
                        this.TranslateToIL(il, (double)1.0 / (double)0.0, rtype);
                    }
                    else if ((rtype != Typeob.Object) && !rtype.IsValueType)
                    {
                        il.Emit(OpCodes.Ldnull);
                    }
                    else
                    {
                        il.Emit(OpCodes.Ldsfld, CompilerGlobals.systemReflectionMissingField);
                        Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, rtype);
                    }
                }
                else
                {
                    if (val == this.value)
                    {
                        throw new JScriptException(JSError.InternalError, base.context);
                    }
                    this.TranslateToIL(il, this.value, rtype);
                }
                return;
            }
            if (!rtype.IsEnum)
            {
                if (val is EnumWrapper)
                {
                    Microsoft.JScript.Convert.Emit(this, il, ((EnumWrapper)val).type, rtype);
                }
                else
                {
                    Microsoft.JScript.Convert.Emit(this, il, Typeob.Int64, rtype);
                }
            }
        }
Beispiel #22
0
        public Object EvaluateUnary(Object v)
        {
            IConvertible ic = Convert.GetIConvertible(v);

            switch (Convert.GetTypeCode(v, ic))
            {
            case TypeCode.Empty:  return(this.EvaluateUnary(Double.NaN));

            case TypeCode.DBNull: return(this.EvaluateUnary(0));

            case TypeCode.Boolean: return(this.EvaluateUnary(ic.ToBoolean(null) ? 1 : 0));

            case TypeCode.Char: return(this.EvaluateUnary((int)ic.ToChar(null)));

            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
                int i = ic.ToInt32(null);
                switch (this.operatorTok)
                {
                case JSToken.BitwiseNot:
                    return(~i);

                case JSToken.LogicalNot:
                    return(i == 0);

                case JSToken.Minus:
                    if (i == 0)
                    {
                        return(-(double)i);
                    }
                    if (i == Int32.MinValue)
                    {
                        return((ulong)-(double)i);
                    }
                    return(-i);

                case JSToken.Plus:
                    return(i);

                default:
                    throw new JScriptException(JSError.InternalError, this.context);
                }

            case TypeCode.UInt32:
                uint ui = ic.ToUInt32(null);
                switch (this.operatorTok)
                {
                case JSToken.BitwiseNot:
                    return(~ui);

                case JSToken.LogicalNot:
                    return(ui == 0);

                case JSToken.Minus:
                    if (ui != 0 && ui <= Int32.MaxValue)
                    {
                        return(-(int)ui);
                    }
                    else
                    {
                        return(-(double)ui);
                    }

                case JSToken.Plus:
                    return(ui);

                default:
                    throw new JScriptException(JSError.InternalError, this.context);
                }

            case TypeCode.Int64:
                long l = ic.ToInt64(null);
                switch (this.operatorTok)
                {
                case JSToken.BitwiseNot:
                    return(~l);

                case JSToken.LogicalNot:
                    return(l == 0);

                case JSToken.Minus:
                    if (l == 0 || l == Int64.MinValue)
                    {
                        return(-(double)l);
                    }
                    return(-l);

                case JSToken.Plus:
                    return(l);

                default:
                    throw new JScriptException(JSError.InternalError, this.context);
                }

            case TypeCode.UInt64:
                ulong ul = ic.ToUInt64(null);
                switch (this.operatorTok)
                {
                case JSToken.BitwiseNot:
                    return(~ul);

                case JSToken.LogicalNot:
                    return(ul == 0);

                case JSToken.Minus:
                    if (ul != 0 && ul <= Int64.MaxValue)
                    {
                        return(-(long)ul);
                    }
                    else
                    {
                        return(-(double)ul);
                    }

                case JSToken.Plus:
                    return(ul);

                default:
                    throw new JScriptException(JSError.InternalError, this.context);
                }

            case TypeCode.Single:
            case TypeCode.Double:
                double d = ic.ToDouble(null);
                switch (this.operatorTok)
                {
                case JSToken.BitwiseNot:
                    return(~(int)Runtime.DoubleToInt64(d));

                case JSToken.LogicalNot:
                    return(!Convert.ToBoolean(d));

                case JSToken.Minus:
                    return(-d);

                case JSToken.Plus:
                    return(d);

                default:
                    throw new JScriptException(JSError.InternalError, this.context);
                }

            case TypeCode.String:
                goto no_overload_case;
            }

            MethodInfo oper = this.GetOperator(v.GetType());

            if (oper != null)
            {
                return(oper.Invoke(null, (BindingFlags)0, JSBinder.ob, new Object[] { v }, null));
            }
no_overload_case:
            switch (this.operatorTok)
            {
            case JSToken.BitwiseNot:
                return(~Convert.ToInt32(v, ic));

            case JSToken.LogicalNot:
                return(!Convert.ToBoolean(v, ic));

            case JSToken.Minus:
                return(-Convert.ToNumber(v, ic));

            case JSToken.Plus:
                return(Convert.ToNumber(v, ic));

            default:
                throw new JScriptException(JSError.InternalError, this.context);
            }
        }
        public static ArrayObject splice(object thisob, VsaEngine engine, double start, double deleteCnt, params object[] args)
        {
            uint oldLength = Microsoft.JScript.Convert.ToUint32(LateBinding.GetMemberValue(thisob, "length"));
            long num2      = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(start));

            if (num2 < 0L)
            {
                num2 = oldLength + num2;
                if (num2 < 0L)
                {
                    num2 = 0L;
                }
            }
            else if (num2 > oldLength)
            {
                num2 = oldLength;
            }
            long num3 = Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(deleteCnt));

            if (num3 < 0L)
            {
                num3 = 0L;
            }
            else if (num3 > (oldLength - num2))
            {
                num3 = oldLength - num2;
            }
            long        num4     = (oldLength + args.Length) - num3;
            ArrayObject outArray = engine.GetOriginalArrayConstructor().Construct();

            outArray.length = num3;
            if (thisob is ArrayObject)
            {
                ((ArrayObject)thisob).Splice((uint)num2, (uint)num3, args, outArray, oldLength, (uint)num4);
                return(outArray);
            }
            for (ulong i = 0L; i < num3; i += (ulong)1L)
            {
                outArray.SetValueAtIndex((uint)i, LateBinding.GetValueAtIndex(thisob, i + ((ulong)num2)));
            }
            long num6 = (oldLength - num2) - num3;

            if (num4 < oldLength)
            {
                for (long k = 0L; k < num6; k += 1L)
                {
                    LateBinding.SetValueAtIndex(thisob, (ulong)((k + num2) + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)((k + num2) + num3)));
                }
                LateBinding.SetMemberValue(thisob, "length", num4);
            }
            else
            {
                LateBinding.SetMemberValue(thisob, "length", num4);
                for (long m = num6 - 1L; m >= 0L; m -= 1L)
                {
                    LateBinding.SetValueAtIndex(thisob, (ulong)((m + num2) + args.Length), LateBinding.GetValueAtIndex(thisob, (ulong)((m + num2) + num3)));
                }
            }
            int num9 = (args == null) ? 0 : args.Length;

            for (uint j = 0; j < num9; j++)
            {
                LateBinding.SetValueAtIndex(thisob, (ulong)(j + num2), args[j]);
            }
            return(outArray);
        }
        public static string substr(object thisob, double start, object count)
        {
            string str = thisob as string;

            if (str == null)
            {
                str = Microsoft.JScript.Convert.ToString(thisob);
            }
            int    length = str.Length;
            double val    = Microsoft.JScript.Convert.ToInteger(start);

            if (val < 0.0)
            {
                val += length;
            }
            if (val < 0.0)
            {
                val = 0.0;
            }
            else if (val > length)
            {
                val = length;
            }
            int num3 = (count is int) ? ((int)count) : (((count == null) || (count is Missing)) ? (length - ((int)Runtime.DoubleToInt64(val))) : ((int)Runtime.DoubleToInt64(Microsoft.JScript.Convert.ToInteger(count))));

            if ((val + num3) > length)
            {
                num3 = length - ((int)val);
            }
            if (num3 <= 0)
            {
                return("");
            }
            return(str.Substring((int)val, num3));
        }