FormatBigInteger() [2/2]

static string System.Numerics.BigNumber.FormatBigInteger ( bool targetSpan, BigInteger value, string formatString, ReadOnlySpan< char > formatSpan, NumberFormatInfo info, Span< char > destination, out int charsWritten, out bool spanSuccess )

inlinestaticprivate

Definition at line 433 of file BigNumber.cs.

    {
        int digits = 0;
        char c = ParseFormatSpecifier(formatSpan, out digits);
        if (c == 'x' || c == 'X')
        {
            return FormatBigIntegerToHex(targetSpan, value, c, digits, info, destination, out charsWritten, out spanSuccess);
        }
        if (value._bits == null)
        {
            if (c == 'g' || c == 'G' || c == 'r' || c == 'R')
            {
                formatSpan = (formatString = ((digits > 0) ? $"D{digits}" : "D"));
            }
            if (targetSpan)
            {
                spanSuccess = value._sign.TryFormat(destination, out charsWritten, formatSpan, info);
                return null;
            }
            charsWritten = 0;
            spanSuccess = false;
            return value._sign.ToString(formatString, info);
        }
        int num = value._bits.Length;
        uint[] array;
        int num3;
        int num4;
        checked
        {
            int num2;
            try
            {
                num2 = unchecked(checked(num * 10) / 9) + 2;
            }
            catch (OverflowException innerException)
            {
                throw new FormatException(System.SR.Format_TooLarge, innerException);
            }
            array = new uint[num2];
            num3 = 0;
            num4 = num;
        }
        while (--num4 >= 0)
        {
            uint num5 = value._bits[num4];
            for (int i = 0; i < num3; i++)
            {
                ulong num6 = NumericsHelpers.MakeUlong(array[i], num5);
                array[i] = (uint)(num6 % 1000000000);
                num5 = (uint)(num6 / 1000000000);
            }
            if (num5 != 0)
            {
                array[num3++] = num5 % 1000000000;
                num5 /= 1000000000;
                if (num5 != 0)
                {
                    array[num3++] = num5;
                }
            }
        }
        int num7;
        bool flag;
        char[] array2;
        int num9;
        checked
        {
            try
            {
                num7 = num3 * 9;
            }
            catch (OverflowException innerException2)
            {
                throw new FormatException(System.SR.Format_TooLarge, innerException2);
            }
            flag = c == 'g' || c == 'G' || c == 'd' || c == 'D' || c == 'r' || c == 'R';
            if (flag)
            {
                if (digits > 0 && digits > num7)
                {
                    num7 = digits;
                }
                if (value._sign < 0)
                {
                    try
                    {
                        num7 += info.NegativeSign.Length;
                    }
                    catch (OverflowException innerException3)
                    {
                        throw new FormatException(System.SR.Format_TooLarge, innerException3);
                    }
                }
            }
            int num8;
            try
            {
                num8 = num7 + 1;
            }
            catch (OverflowException innerException4)
            {
                throw new FormatException(System.SR.Format_TooLarge, innerException4);
            }
            array2 = new char[num8];
            num9 = num7;
        }
        for (int j = 0; j < num3 - 1; j++)
        {
            uint num10 = array[j];
            int num11 = 9;
            while (--num11 >= 0)
            {
                array2[--num9] = (char)(48 + num10 % 10);
                num10 /= 10;
            }
        }
        for (uint num12 = array[num3 - 1]; num12 != 0; num12 /= 10)
        {
            array2[--num9] = (char)(48 + num12 % 10);
        }
        if (!flag)
        {
            bool sign = value._sign < 0;
            int precision = 29;
            int scale = num7 - num9;
            Span<char> initialBuffer = stackalloc char[128];
            System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer);
            FormatProvider.FormatBigInteger(ref sb, precision, scale, sign, formatSpan, info, array2, num9);
            if (targetSpan)
            {
                spanSuccess = sb.TryCopyTo(destination, out charsWritten);
                return null;
            }
            charsWritten = 0;
            spanSuccess = false;
            return sb.ToString();
        }
        int num13 = num7 - num9;
        while (digits > 0 && digits > num13)
        {
            array2[--num9] = '0';
            digits--;
        }
        if (value._sign < 0)
        {
            string negativeSign = info.NegativeSign;
            for (int num14 = negativeSign.Length - 1; num14 > -1; num14--)
            {
                array2[--num9] = negativeSign[num14];
            }
        }
        int num15 = num7 - num9;
        if (!targetSpan)
        {
            charsWritten = 0;
            spanSuccess = false;
            return new string(array2, num9, num7 - num9);
        }
        if (new ReadOnlySpan<char>(array2, num9, num7 - num9).TryCopyTo(destination))
        {
            charsWritten = num15;
            spanSuccess = true;
            return null;
        }
        charsWritten = 0;
        spanSuccess = false;
        return null;
    }

References System.array, System.destination, System.SR.Format_TooLarge, System.Globalization.FormatProvider.FormatBigInteger(), System.Numerics.BigNumber.FormatBigIntegerToHex(), System.info, System.Numerics.NumericsHelpers.MakeUlong(), System.Numerics.BigNumber.ParseFormatSpecifier(), System.Text.ValueStringBuilder.ToString(), System.ReadOnlySpan< T >.ToString(), System.Text.ValueStringBuilder.TryCopyTo(), and System.value.