sebastienros.jint/Jint/Native/Number/NumberPrototype.cs

using System.Diagnostics;
using System.Globalization;
using System.Text;
using Jint.Collections;
using Jint.Native.Number.Dtoa;
using Jint.Native.Object;
using Jint.Runtime;
using Jint.Runtime.Descriptors;
using Jint.Runtime.Interop;

namespace Jint.Native.Number;

/// <summary>
/// https://tc39.es/ecma262/#sec-properties-of-the-number-prototype-object
/// </summary>
internal sealed class NumberPrototype : NumberInstance
{
    private const int SmallDtoaLength = FastDtoa.KFastDtoaMaximalLength + 8;
    private const int LargeDtoaLength = 101;

    private readonly Realm _realm;
    private readonly NumberConstructor _constructor;

    internal NumberPrototype(
        Engine engine,
        Realm realm,
        NumberConstructor constructor,
        ObjectPrototype objectPrototype)
        : base(engine, InternalTypes.Object | InternalTypes.PlainObject)
    {
        _prototype = objectPrototype;
        _realm = realm;
        _constructor = constructor;
    }

    protected override void Initialize()
    {
        var properties = new PropertyDictionary(8, checkExistingKeys: false)
        {
            ["constructor"] = new PropertyDescriptor(_constructor, true, false, true),
            ["toString"] = new PropertyDescriptor(new ClrFunction(Engine, "toString", ToNumberString, 1, PropertyFlag.Configurable), true, false, true),
            ["toLocaleString"] = new PropertyDescriptor(new ClrFunction(Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), true, false, true),
            ["valueOf"] = new PropertyDescriptor(new ClrFunction(Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), true, false, true),
            ["toFixed"] = new PropertyDescriptor(new ClrFunction(Engine, "toFixed", ToFixed, 1, PropertyFlag.Configurable), true, false, true),
            ["toExponential"] = new PropertyDescriptor(new ClrFunction(Engine, "toExponential", ToExponential, 1, PropertyFlag.Configurable), true, false, true),
            ["toPrecision"] = new PropertyDescriptor(new ClrFunction(Engine, "toPrecision", ToPrecision, 1, PropertyFlag.Configurable), true, false, true)
        };
        SetProperties(properties);
    }

    private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
    {
        if (!thisObject.IsNumber() && ReferenceEquals(thisObject.TryCast<NumberInstance>(), null))
        {
            ExceptionHelper.ThrowTypeError(_realm);
        }

        var m = TypeConverter.ToNumber(thisObject);

        if (double.IsNaN(m))
        {
            return "NaN";
        }

        if (m == 0)
        {
            return JsString.NumberZeroString;
        }

        if (m < 0)
        {
            return "-" + ToLocaleString(-m, arguments);
        }

        if (double.IsPositiveInfinity(m) || m >= double.MaxValue)
        {
            return "Infinity";
        }

        if (double.IsNegativeInfinity(m) || m <= -double.MaxValue)
        {
            return "-Infinity";
        }

        var numberFormat = (NumberFormatInfo) Engine.Options.Culture.NumberFormat.Clone();

        try
        {
            if (arguments.Length > 0 && arguments[0].IsString())
            {
                var cultureArgument = arguments[0].ToString();
                numberFormat = (NumberFormatInfo) CultureInfo.GetCultureInfo(cultureArgument).NumberFormat.Clone();
            }

            int decDigitCount = NumberIntlHelper.GetDecimalDigitCount(m);
            numberFormat.NumberDecimalDigits = decDigitCount;
        }
        catch (CultureNotFoundException)
        {
            ExceptionHelper.ThrowRangeError(_realm, "Incorrect locale information provided");
        }

        return m.ToString("n", numberFormat);
    }

    private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
    {
        if (thisObject is NumberInstance ni)
        {
            return ni.NumberData;
        }

        if (thisObject is JsNumber)
        {
            return thisObject;
        }

        ExceptionHelper.ThrowTypeError(_realm);
        return null;
    }

    private const double Ten21 = 1e21;

    private JsValue ToFixed(JsValue thisObject, JsValue[] arguments)
    {
        var f = (int) TypeConverter.ToInteger(arguments.At(0, 0));
        if (f < 0 || f > 100)
        {
            ExceptionHelper.ThrowRangeError(_realm, "fractionDigits argument must be between 0 and 100");
        }

        // limitation with .NET, max is 99
        if (f == 100)
        {
            ExceptionHelper.ThrowRangeError(_realm, "100 fraction digits is not supported due to .NET format specifier limitation");
        }

        var x = TypeConverter.ToNumber(thisObject);

        if (double.IsNaN(x))
        {
            return "NaN";
        }

        if (x >= Ten21)
        {
            return ToNumberString(x);
        }

        // handle non-decimal with greater precision
        if (System.Math.Abs(x - (long) x) < JsNumber.DoubleIsIntegerTolerance)
        {
            return ((long) x).ToString("f" + f, CultureInfo.InvariantCulture);
        }

        return x.ToString("f" + f, CultureInfo.InvariantCulture);
    }

    /// <summary>
    /// https://www.ecma-international.org/ecma-262/6.0/#sec-number.prototype.toexponential
    /// </summary>
    private JsValue ToExponential(JsValue thisObject, JsValue[] arguments)
    {
        if (!thisObject.IsNumber() && ReferenceEquals(thisObject.TryCast<NumberInstance>(), null))
        {
            ExceptionHelper.ThrowTypeError(_realm);
        }

        var x = TypeConverter.ToNumber(thisObject);
        var fractionDigits = arguments.At(0);
        if (fractionDigits.IsUndefined())
        {
            fractionDigits = JsNumber.PositiveZero;
        }

        var f = (int) TypeConverter.ToInteger(fractionDigits);

        if (double.IsNaN(x))
        {
            return "NaN";
        }

        if (double.IsInfinity(x))
        {
            return thisObject.ToString();
        }

        if (f < 0 || f > 100)
        {
            ExceptionHelper.ThrowRangeError(_realm, "fractionDigits argument must be between 0 and 100");
        }

        if (arguments.At(0).IsUndefined())
        {
            f = -1;
        }

        bool negative = false;
        if (x < 0)
        {
            x = -x;
            negative = true;
        }

        int decimalPoint;
        var dtoaBuilder = new DtoaBuilder(stackalloc char[f == -1 ? SmallDtoaLength : LargeDtoaLength]);

        if (f == -1)
        {
            DtoaNumberFormatter.DoubleToAscii(
                ref dtoaBuilder,
                x,
                DtoaMode.Shortest,
                requested_digits: 0,
                out _,
                out decimalPoint);
            f = dtoaBuilder.Length - 1;
        }
        else
        {
            DtoaNumberFormatter.DoubleToAscii(
                ref dtoaBuilder,
                x,
                DtoaMode.Precision,
                requested_digits: f + 1,
                out _,
                out decimalPoint);
        }

        Debug.Assert(dtoaBuilder.Length > 0);
        Debug.Assert(dtoaBuilder.Length <= f + 1);

        int exponent = decimalPoint - 1;
        var result = CreateExponentialRepresentation(ref dtoaBuilder, exponent, negative, f+1);
        return result;
    }

    private JsValue ToPrecision(JsValue thisObject, JsValue[] arguments)
    {
        if (!thisObject.IsNumber() && ReferenceEquals(thisObject.TryCast<NumberInstance>(), null))
        {
            ExceptionHelper.ThrowTypeError(_realm);
        }

        var x = TypeConverter.ToNumber(thisObject);
        var precisionArgument = arguments.At(0);

        if (precisionArgument.IsUndefined())
        {
            return TypeConverter.ToString(x);
        }

        var p = (int) TypeConverter.ToInteger(precisionArgument);

        if (double.IsNaN(x))
        {
            return "NaN";
        }

        if (double.IsInfinity(x))
        {
            return thisObject.ToString();
        }

        if (p < 1 || p > 100)
        {
            ExceptionHelper.ThrowRangeError(_realm, "precision must be between 1 and 100");
        }

        var dtoaBuilder = new DtoaBuilder(stackalloc char[LargeDtoaLength]);
        DtoaNumberFormatter.DoubleToAscii(
            ref dtoaBuilder,
            x,
            DtoaMode.Precision,
            p,
            out var negative,
            out var decimalPoint);


        int exponent = decimalPoint - 1;
        if (exponent < -6 || exponent >= p)
        {
            return CreateExponentialRepresentation(ref dtoaBuilder, exponent, negative, p);
        }

        var sb = new ValueStringBuilder(stackalloc char[128]);

        // Use fixed notation.
        if (negative)
        {
            sb.Append('-');
        }

        if (decimalPoint <= 0)
        {
            sb.Append("0.");
            sb.Append('0', -decimalPoint);
            sb.Append(dtoaBuilder._chars.Slice(0, dtoaBuilder.Length));
            sb.Append('0', p - dtoaBuilder.Length);
        }
        else
        {
            int m = System.Math.Min(dtoaBuilder.Length, decimalPoint);
            sb.Append(dtoaBuilder._chars.Slice(0, m));
            sb.Append('0', System.Math.Max(0, decimalPoint - dtoaBuilder.Length));
            if (decimalPoint < p)
            {
                sb.Append('.');
                var extra = negative ? 2 : 1;
                if (dtoaBuilder.Length > decimalPoint)
                {
                    int len = dtoaBuilder.Length - decimalPoint;
                    int n = System.Math.Min(len, p - (sb.Length - extra));
                    sb.Append(dtoaBuilder._chars.Slice(decimalPoint, n));
                }

                sb.Append('0', System.Math.Max(0, extra + (p - sb.Length)));
            }
        }

        return sb.ToString();
    }

    private static string CreateExponentialRepresentation(
        ref  DtoaBuilder buffer,
        int exponent,
        bool negative,
        int significantDigits)
    {
        bool negativeExponent = false;
        if (exponent < 0)
        {
            negativeExponent = true;
            exponent = -exponent;
        }

        var sb = new ValueStringBuilder(stackalloc char[128]);
        if (negative)
        {
            sb.Append('-');
        }
        sb.Append(buffer[0]);
        if (significantDigits != 1)
        {
            sb.Append('.');
            sb.Append(buffer.Slice(1, buffer.Length - 1));
            int length = buffer.Length;
            sb.Append('0', significantDigits - length);
        }

        sb.Append('e');
        sb.Append(negativeExponent ? '-' : '+');
        sb.Append(exponent.ToString(CultureInfo.InvariantCulture));

        return sb.ToString();
    }

    private JsValue ToNumberString(JsValue thisObject, JsValue[] arguments)
    {
        if (!thisObject.IsNumber() && (ReferenceEquals(thisObject.TryCast<NumberInstance>(), null)))
        {
            ExceptionHelper.ThrowTypeError(_realm);
        }

        var radix = arguments.At(0).IsUndefined()
            ? 10
            : (int) TypeConverter.ToInteger(arguments.At(0));

        if (radix < 2 || radix > 36)
        {
            ExceptionHelper.ThrowRangeError(_realm, "radix must be between 2 and 36");
        }

        var x = TypeConverter.ToNumber(thisObject);

        if (double.IsNaN(x))
        {
            return "NaN";
        }

        if (x == 0)
        {
            return JsString.NumberZeroString;
        }

        if (double.IsPositiveInfinity(x) || x >= double.MaxValue)
        {
            return "Infinity";
        }

        if (x < 0)
        {
            return "-" + ToNumberString(-x, arguments);
        }

        if (radix == 10)
        {
            return ToNumberString(x);
        }

        var integer = (long) x;
        var fraction = x -  integer;

        string result = NumberPrototype.ToBase(integer, radix);
        if (fraction != 0)
        {
            result += "." + NumberPrototype.ToFractionBase(fraction, radix);
        }

        return result;
    }

    internal static string ToBase(long n, int radix)
    {
        const string Digits = "0123456789abcdefghijklmnopqrstuvwxyz";
        if (n == 0)
        {
            return "0";
        }

        var sb = new ValueStringBuilder(stackalloc char[64]);
        while (n > 0)
        {
            var digit = (int) (n % radix);
            n /= radix;
            sb.Append(Digits[digit]);
        }
        sb.Reverse();
        return sb.ToString();
    }

    internal static string ToFractionBase(double n, int radix)
    {
        // based on the repeated multiplication method
        // http://www.mathpath.org/concepts/Num/frac.htm

        const string Digits = "0123456789abcdefghijklmnopqrstuvwxyz";
        if (n == 0)
        {
            return "0";
        }

        var result = new ValueStringBuilder(stackalloc char[64]);
        while (n > 0 && result.Length < 50) // arbitrary limit
        {
            var c = n*radix;
            var d = (int) c;
            n = c - d;

            result.Append(Digits[d]);
        }

        return result.ToString();
    }

    internal static string ToNumberString(double m)
    {
        if (double.IsNaN(m))
        {
            return "NaN";
        }

        if (m == 0)
        {
            return "0";
        }

        if (double.IsInfinity(m))
        {
            return double.IsNegativeInfinity(m) ? "-Infinity" : "Infinity";
        }

        var builder = new DtoaBuilder(stackalloc char[SmallDtoaLength]);

        DtoaNumberFormatter.DoubleToAscii(
            ref builder,
            m,
            DtoaMode.Shortest,
            0,
            out var negative,
            out var decimal_point);


        var stringBuilder = new ValueStringBuilder(stackalloc char[64]);
        if (negative)
        {
            stringBuilder.Append('-');
        }

        if (builder.Length <= decimal_point && decimal_point <= 21)
        {
            // ECMA-262 section 9.8.1 step 6.
            stringBuilder.Append(builder._chars.Slice(0, builder.Length));
            stringBuilder.Append('0', decimal_point - builder.Length);
        }
        else if (0 < decimal_point && decimal_point <= 21)
        {
            // ECMA-262 section 9.8.1 step 7.
            stringBuilder.Append(builder._chars.Slice(0, decimal_point));
            stringBuilder.Append('.');
            stringBuilder.Append(builder._chars.Slice(decimal_point, builder.Length - decimal_point));
        }
        else if (decimal_point <= 0 && decimal_point > -6)
        {
            // ECMA-262 section 9.8.1 step 8.
            stringBuilder.Append("0.");
            stringBuilder.Append('0', -decimal_point);
            stringBuilder.Append(builder._chars.Slice(0, builder.Length));
        }
        else
        {
            // ECMA-262 section 9.8.1 step 9 and 10 combined.
            stringBuilder.Append(builder._chars[0]);
            if (builder.Length != 1)
            {
                stringBuilder.Append('.');
                stringBuilder.Append(builder._chars.Slice(1, builder.Length - 1));
            }

            stringBuilder.Append('e');
            stringBuilder.Append((decimal_point >= 0) ? '+' : '-');
            int exponent = decimal_point - 1;
            if (exponent < 0)
            {
                exponent = -exponent;
            }

            stringBuilder.Append(exponent.ToString(CultureInfo.InvariantCulture));
        }

        return stringBuilder.ToString();
    }
}