BigInteger() [9/12]

System.Numerics.BigInteger.BigInteger ( ReadOnlySpan< byte > value, bool isUnsigned = false, bool isBigEndian = false )

inline

Definition at line 288 of file BigInteger.cs.

    {
        int num = value.Length;
        bool flag;
        if (num > 0)
        {
            byte b = (isBigEndian ? value[0] : value[num - 1]);
            flag = (b & 0x80u) != 0 && !isUnsigned;
            if (b == 0)
            {
                if (isBigEndian)
                {
                    int i;
                    for (i = 1; i < num && value[i] == 0; i++)
                    {
                    }
                    value = value.Slice(i);
                    num = value.Length;
                }
                else
                {
                    num -= 2;
                    while (num >= 0 && value[num] == 0)
                    {
                        num--;
                    }
                    num++;
                }
            }
        }
        else
        {
            flag = false;
        }
        if (num == 0)
        {
            _sign = 0;
            _bits = null;
            return;
        }
        if (num <= 4)
        {
            _sign = (flag ? (-1) : 0);
            if (isBigEndian)
            {
                for (int j = 0; j < num; j++)
                {
                    _sign = (_sign << 8) | value[j];
                }
            }
            else
            {
                for (int num2 = num - 1; num2 >= 0; num2--)
                {
                    _sign = (_sign << 8) | value[num2];
                }
            }
            _bits = null;
            if (_sign < 0 && !flag)
            {
                _bits = new uint[1] { (uint)_sign };
                _sign = 1;
            }
            if (_sign == int.MinValue)
            {
                this = s_bnMinInt;
            }
            return;
        }
        int num3 = num % 4;
        int num4 = num / 4 + ((num3 != 0) ? 1 : 0);
        uint[] array = new uint[num4];
        int num5 = num - 1;
        int k;
        if (isBigEndian)
        {
            int num6 = num - 4;
            for (k = 0; k < num4 - ((num3 != 0) ? 1 : 0); k++)
            {
                for (int l = 0; l < 4; l++)
                {
                    byte b2 = value[num6];
                    array[k] = (array[k] << 8) | b2;
                    num6++;
                }
                num6 -= 8;
            }
        }
        else
        {
            int num6 = 3;
            for (k = 0; k < num4 - ((num3 != 0) ? 1 : 0); k++)
            {
                for (int m = 0; m < 4; m++)
                {
                    byte b3 = value[num6];
                    array[k] = (array[k] << 8) | b3;
                    num6--;
                }
                num6 += 8;
            }
        }
        if (num3 != 0)
        {
            if (flag)
            {
                array[num4 - 1] = uint.MaxValue;
            }
            if (isBigEndian)
            {
                for (int num6 = 0; num6 < num3; num6++)
                {
                    byte b4 = value[num6];
                    array[k] = (array[k] << 8) | b4;
                }
            }
            else
            {
                for (int num6 = num5; num6 >= num - num3; num6--)
                {
                    byte b5 = value[num6];
                    array[k] = (array[k] << 8) | b5;
                }
            }
        }
        if (flag)
        {
            NumericsHelpers.DangerousMakeTwosComplement(array);
            int num7 = array.Length - 1;
            while (num7 >= 0 && array[num7] == 0)
            {
                num7--;
            }
            num7++;
            if (num7 == 1)
            {
                switch (array[0])
                {
                case 1u:
                    this = s_bnMinusOneInt;
                    return;
                case 2147483648u:
                    this = s_bnMinInt;
                    return;
                }
                if ((int)array[0] > 0)
                {
                    _sign = -1 * (int)array[0];
                    _bits = null;
                    return;
                }
            }
            if (num7 != array.Length)
            {
                _sign = -1;
                _bits = new uint[num7];
                Array.Copy(array, _bits, num7);
            }
            else
            {
                _sign = -1;
                _bits = array;
            }
        }
        else
        {
            _sign = 1;
            _bits = array;
        }
    }

References System.Numerics.BigInteger._bits, System.Numerics.BigInteger._sign, System.array, System.Array.Copy(), System.Numerics.NumericsHelpers.DangerousMakeTwosComplement(), System.Numerics.BigInteger.s_bnMinInt, System.Numerics.BigInteger.s_bnMinusOneInt, and System.value.