ToInteger() static private method

static private ToInteger ( Object value ) : double
value Object
return double
Example #1
0
        public static String toExponential(Object thisob, Object fractionDigits)
        {
            double value = NumberPrototype.ThisobToDouble(thisob);
            double f;

            if (fractionDigits == null || fractionDigits is Missing)
            {
                f = 16;
            }
            else
            {
                f = Convert.ToInteger(fractionDigits);
            }
            if (f < 0 || f > 20)
            {
                throw new JScriptException(JSError.FractionOutOfRange);
            }
            StringBuilder fmt = new StringBuilder("#.");

            for (int i = 0; i < f; i++)
            {
                fmt.Append('0');
            }
            fmt.Append("e+0");
            return(value.ToString(fmt.ToString(), CultureInfo.InvariantCulture));
        }
Example #2
0
        internal bool test(String input)
        {
            Match match = null;

            if (!this.globalInt)
            {
                match = this.regex.Match(input);
            }
            else
            {
                int lastIndex = (int)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);
        }
Example #3
0
        internal Object exec(String input)
        {
            Match match = null;

            if (!this.globalInt)
            {
                match = this.regex.Match(input);
            }
            else
            {
                int lastIndex = (int)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));
        }
Example #4
0
        public static String toPrecision(Object thisob, Object precision)
        {
            double value = NumberPrototype.ThisobToDouble(thisob);

            if (precision == null || precision is Missing)
            {
                return(Convert.ToString(value));
            }
            double df = Convert.ToInteger(precision);

            if (df < 1 || df > 21)
            {
                throw new JScriptException(JSError.PrecisionOutOfRange);
            }
            int f = (int)df;

            if (Double.IsNaN(value))
            {
                return("NaN");
            }
            if (Double.IsInfinity(value))
            {
                return(value > 0.0 ? "Infinity" : "-Infinity");
            }
            String sign;

            if (value >= 0.0)
            {
                sign = "";
            }
            else
            {
                sign  = "-";
                value = -value;
            }
            String mant = value.ToString("e" + (f - 1).ToString(), CultureInfo.InvariantCulture);
            int    exp  = Int32.Parse(mant.Substring(mant.Length - 4), CultureInfo.InvariantCulture);

            mant = mant.Substring(0, 1) + mant.Substring(2, f - 1);
            if (exp >= f || exp < -6)
            {
                return(sign + mant.Substring(0, 1) + (f > 1 ? "." + mant.Substring(1) : "")
                       + (exp >= 0 ? "e+" : "e") + exp.ToString());
            }
            if (exp == f - 1)
            {
                return(sign + mant);
            }
            if (exp >= 0)
            {
                return(sign + mant.Substring(0, exp + 1) + "." + mant.Substring(exp + 1));
            }
            return(sign + "0." + mant.PadLeft(f - exp - 1, '0'));
        }
Example #5
0
        public static Object charCodeAt(Object thisob, double pos) //This returns an object so that integers stay integers
        {
            String thisStr  = Convert.ToString(thisob);
            double position = Convert.ToInteger(pos);

            if (position < 0 || !(position < thisStr.Length))
            {
                return(Double.NaN);
            }
            return((int)(thisStr[(int)position]));
        }
Example #6
0
        public static String charAt(Object thisob, double pos)
        {
            String thisStr  = Convert.ToString(thisob);
            double position = Convert.ToInteger(pos);

            if (position < 0 || !(position < thisStr.Length))
            {
                return("");
            }
            return(thisStr.Substring((int)position, 1));
        }
        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);
        }
Example #8
0
        public static int indexOf(Object thisob, Object searchString, double position)
        {
            String thisStr    = Convert.ToString(thisob);
            String searchStr  = Convert.ToString(searchString);
            double startIndex = Convert.ToInteger(position);
            int    length     = thisStr.Length;

            if (startIndex < 0)
            {
                startIndex = 0;
            }
            if (startIndex >= length)
            {
                return(searchStr.Length == 0 ? 0 : -1);
            }
            return(thisStr.IndexOf(searchStr, (int)startIndex));
        }
Example #9
0
        public static String slice(Object thisob, double start, Object end)
        {
            String thisStr    = Convert.ToString(thisob);
            int    length     = thisStr.Length;
            double startIndex = Convert.ToInteger(start);
            double endIndex   = (end == null || end is Missing)
          ? length : Convert.ToInteger(end);

            if (startIndex < 0)
            {
                startIndex = length + startIndex;
                if (startIndex < 0)
                {
                    startIndex = 0;
                }
            }
            else
            if (startIndex > length)
            {
                startIndex = length;
            }
            if (endIndex < 0)
            {
                endIndex = length + endIndex;
                if (endIndex < 0)
                {
                    endIndex = 0;
                }
            }
            else
            if (endIndex > length)
            {
                endIndex = length;
            }
            int nChars = (int)(endIndex - startIndex);

            if (nChars <= 0)
            {
                return("");
            }
            else
            {
                return(thisStr.Substring((int)startIndex, nChars));
            }
        }
Example #10
0
        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)startIndex : (int)Convert.ToInteger(count));

            if (startIndex + nChars > length)
            {
                nChars = length - (int)startIndex;
            }
            if (nChars <= 0)
            {
                return("");
            }
            else
            {
                return(thisStr.Substring((int)startIndex, nChars));
            }
        }
Example #11
0
        public static String substring(Object thisob, double start, Object end)
        {
            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 = 0;
            }
            else if (startIndex > length)
            {
                startIndex = length;
            }
            double endIndex = (end == null || end is Missing)
          ? length : Convert.ToInteger(end);

            if (endIndex < 0)
            {
                endIndex = 0;
            }
            else if (endIndex > length)
            {
                endIndex = length;
            }
            if (startIndex > endIndex)
            {
                double temp = startIndex;
                startIndex = endIndex;
                endIndex   = temp;
            }
            return(thisStr.Substring((int)startIndex, (int)(endIndex - startIndex)));
        }
Example #12
0
        public static ArrayObject split(Object thisob, VsaEngine engine, Object separator, Object limit)
        {
            String thisStr    = Convert.ToString(thisob);
            uint   limitValue = UInt32.MaxValue;

            if (limit != null && !(limit is Missing) && limit != DBNull.Value)
            {
                double lmt = Convert.ToInteger(limit);
                if (lmt >= 0 && lmt < UInt32.MaxValue)
                {
                    limitValue = (uint)lmt;
                }
            }
            if (limitValue == 0)
            {
                return((ArrayObject)engine.GetOriginalArrayConstructor().Construct());
            }
            if (separator == null || separator is Missing)
            {
                ArrayObject array = (ArrayObject)engine.GetOriginalArrayConstructor().Construct();
                array.SetValueAtIndex(0, thisob);
                return(array);
            }
            RegExpObject regExpObject = separator as RegExpObject;

            if (regExpObject != null)
            {
                return(StringPrototype.SplitWithRegExp(thisStr, engine, regExpObject, limitValue));
            }
            Regex regex = separator as Regex;

            if (regex != null)
            {
                return(StringPrototype.SplitWithRegExp(thisStr, engine, new RegExpObject(regex), limitValue));
            }
            return(StringPrototype.SplitWithString(thisStr, engine, Convert.ToString(separator), limitValue));
        }
        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);
        }