NumberToBigInteger()

static bool System.Numerics.BigNumber.NumberToBigInteger ( ref BigNumberBuffer number, out BigInteger result )

inlinestaticprivate

Definition at line 188 of file BigNumber.cs.

    {
        Span<uint> span = stackalloc uint[64];
        Span<uint> currentBuffer2 = span;
        int currentBufferSize = 0;
        int[] arrayFromPool = null;
        uint partialValue = 0u;
        int partialDigitCount = 0;
        int totalDigitCount = 0;
        int numberScale = number.scale;
        try
        {
            StringBuilder.ChunkEnumerator enumerator = number.digits.GetChunks().GetEnumerator();
            while (enumerator.MoveNext())
            {
                if (!ProcessChunk(enumerator.Current.Span, ref currentBuffer2))
                {
                    result = default(BigInteger);
                    return false;
                }
            }
            if (partialDigitCount > 0)
            {
                MultiplyAdd(ref currentBuffer2, s_uint32PowersOfTen[partialDigitCount], partialValue);
            }
            int num;
            for (num = numberScale - totalDigitCount; num >= 9; num -= 9)
            {
                MultiplyAdd(ref currentBuffer2, 1000000000u, 0u);
            }
            if (num > 0)
            {
                MultiplyAdd(ref currentBuffer2, s_uint32PowersOfTen[num], 0u);
            }
            int n;
            uint[] rgu;
            if (currentBufferSize == 0)
            {
                n = 0;
                rgu = null;
            }
            else if (currentBufferSize == 1 && currentBuffer2[0] <= int.MaxValue)
            {
                n = (int)(number.sign ? (0L - (long)currentBuffer2[0]) : currentBuffer2[0]);
                rgu = null;
            }
            else
            {
                n = ((!number.sign) ? 1 : (-1));
                rgu = currentBuffer2.Slice(0, currentBufferSize).ToArray();
            }
            result = new BigInteger(n, rgu);
            return true;
        }
        finally
        {
            if (arrayFromPool != null)
            {
                ArrayPool<int>.Shared.Return(arrayFromPool);
            }
        }
        void MultiplyAdd(ref Span<uint> currentBuffer, uint multiplier, uint addValue)
        {
            Span<uint> span2 = currentBuffer.Slice(0, currentBufferSize);
            uint num2 = addValue;
            for (int i = 0; i < span2.Length; i++)
            {
                ulong num3 = (ulong)((long)multiplier * (long)span2[i] + num2);
                span2[i] = (uint)num3;
                num2 = (uint)(num3 >> 32);
            }
            if (num2 != 0)
            {
                if (currentBufferSize == currentBuffer.Length)
                {
                    int[] array = arrayFromPool;
                    arrayFromPool = ArrayPool<int>.Shared.Rent(checked(currentBufferSize * 2));
                    Span<uint> span3 = MemoryMarshal.Cast<int, uint>(arrayFromPool);
                    currentBuffer.CopyTo(span3);
                    currentBuffer = span3;
                    if (array != null)
                    {
                        ArrayPool<int>.Shared.Return(array);
                    }
                }
                currentBuffer[currentBufferSize] = num2;
                currentBufferSize++;
            }
        }
        bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<uint> currentBuffer)
        {
            int val = Math.Max(numberScale - totalDigitCount, 0);
            ReadOnlySpan<char> readOnlySpan = chunkDigits.Slice(0, Math.Min(val, chunkDigits.Length));
            bool flag = false;
            uint num4 = partialValue;
            int num5 = partialDigitCount;
            int num6 = totalDigitCount;
            for (int j = 0; j < readOnlySpan.Length; j++)
            {
                char c = chunkDigits[j];
                if (c == '\0')
                {
                    flag = true;
                    break;
                }
                num4 = num4 * 10 + (uint)(c - 48);
                num5++;
                num6++;
                if (num5 == 9)
                {
                    MultiplyAdd(ref currentBuffer, 1000000000u, num4);
                    num4 = 0u;
                    num5 = 0;
                }
            }
            if (!flag)
            {
                ReadOnlySpan<char> readOnlySpan2 = chunkDigits.Slice(readOnlySpan.Length);
                for (int k = 0; k < readOnlySpan2.Length; k++)
                {
                    switch (readOnlySpan2[k])
                    {
                    default:
                        return false;
                    case '0':
                        continue;
                    case '\0':
                        break;
                    }
                    break;
                }
            }
            partialValue = num4;
            partialDigitCount = num5;
            totalDigitCount = num6;
            return true;
        }
    }

References System.array, System.Text.StringBuilder.ChunkEnumerator.Current, System.Text.StringBuilder.ChunkEnumerator.GetEnumerator(), System.L, System.ReadOnlySpan< T >.Length, System.Span< T >.Length, System.Math.Max(), System.Math.Min(), System.Text.StringBuilder.ChunkEnumerator.MoveNext(), System.Numerics.BigNumber.s_uint32PowersOfTen, System.Buffers.ArrayPool< T >.Shared, System.ReadOnlySpan< T >.Slice(), System.Span< T >.Slice(), and System.ReadOnlyMemory< T >.Span.

Referenced by System.Numerics.BigNumber.TryParseBigInteger().