VarDecDiv()

static unsafe void System.Decimal.DecCalc.VarDecDiv ( ref DecCalc d1, ref DecCalc d2 )

inlinestaticpackage

Definition at line 1562 of file Decimal.cs.

        {
            Unsafe.SkipInit<Buf12>(out var value);
            int scale = (sbyte)(d1.uflags - d2.uflags >> 16);
            bool flag = false;
            uint low;
            uint num;
            Buf16 value2;
            ulong num7;
            Buf12 value3;
            uint num6;
            if ((d2.High | d2.Mid) == 0)
            {
                low = d2.Low;
                if (low == 0)
                {
                    throw new DivideByZeroException();
                }
                value.Low64 = d1.Low64;
                value.U2 = d1.High;
                num = Div96By32(ref value, low);
                while (true)
                {
                    int num2;
                    if (num == 0)
                    {
                        if (scale >= 0)
                        {
                            break;
                        }
                        num2 = Math.Min(9, -scale);
                    }
                    else
                    {
                        flag = true;
                        if (scale == 28 || (num2 = SearchScale(ref value, scale)) == 0)
                        {
                            goto IL_0090;
                        }
                    }
                    uint num3 = s_powers10[num2];
                    scale += num2;
                    if (IncreaseScale(ref value, num3) == 0)
                    {
                        ulong num4 = UInt32x32To64(num, num3);
                        uint num5 = (uint)(num4 / low);
                        num = (uint)(int)num4 - num5 * low;
                        if (!Add32To96(ref value, num5))
                        {
                            scale = OverflowUnscale(ref value, scale, num != 0);
                            break;
                        }
                        continue;
                    }
                    goto IL_04ab;
                }
            }
            else
            {
                num6 = d2.High;
                if (num6 == 0)
                {
                    num6 = d2.Mid;
                }
                int num2 = BitOperations.LeadingZeroCount(num6);
                Unsafe.SkipInit<Buf16>(out value2);
                value2.Low64 = d1.Low64 << num2;
                value2.High64 = d1.Mid + ((ulong)d1.High << 32) >> 32 - num2;
                num7 = d2.Low64 << num2;
                if (d2.High == 0)
                {
                    value.U2 = 0u;
                    value.U1 = Div96By64(ref *(Buf12*)(&value2.U1), num7);
                    value.U0 = Div96By64(ref *(Buf12*)(&value2), num7);
                    while (true)
                    {
                        if (value2.Low64 == 0L)
                        {
                            if (scale >= 0)
                            {
                                break;
                            }
                            num2 = Math.Min(9, -scale);
                        }
                        else
                        {
                            flag = true;
                            if (scale == 28 || (num2 = SearchScale(ref value, scale)) == 0)
                            {
                                goto IL_01e8;
                            }
                        }
                        uint num3 = s_powers10[num2];
                        scale += num2;
                        if (IncreaseScale(ref value, num3) == 0)
                        {
                            IncreaseScale64(ref *(Buf12*)(&value2), num3);
                            num6 = Div96By64(ref *(Buf12*)(&value2), num7);
                            if (!Add32To96(ref value, num6))
                            {
                                scale = OverflowUnscale(ref value, scale, value2.Low64 != 0);
                                break;
                            }
                            continue;
                        }
                        goto IL_04ab;
                    }
                }
                else
                {
                    Unsafe.SkipInit<Buf12>(out value3);
                    value3.Low64 = num7;
                    value3.U2 = (uint)(d2.Mid + ((ulong)d2.High << 32) >> 32 - num2);
                    value.Low64 = Div128By96(ref value2, ref value3);
                    value.U2 = 0u;
                    while (true)
                    {
                        if ((value2.Low64 | value2.U2) == 0L)
                        {
                            if (scale >= 0)
                            {
                                break;
                            }
                            num2 = Math.Min(9, -scale);
                        }
                        else
                        {
                            flag = true;
                            if (scale == 28 || (num2 = SearchScale(ref value, scale)) == 0)
                            {
                                goto IL_0302;
                            }
                        }
                        uint num3 = s_powers10[num2];
                        scale += num2;
                        if (IncreaseScale(ref value, num3) == 0)
                        {
                            value2.U3 = IncreaseScale(ref *(Buf12*)(&value2), num3);
                            num6 = Div128By96(ref value2, ref value3);
                            if (!Add32To96(ref value, num6))
                            {
                                scale = OverflowUnscale(ref value, scale, (value2.Low64 | value2.High64) != 0);
                                break;
                            }
                            continue;
                        }
                        goto IL_04ab;
                    }
                }
            }
            goto IL_03f3;
            IL_0302:
            if ((int)value2.U2 >= 0)
            {
                num6 = value2.U1 >> 31;
                value2.Low64 <<= 1;
                value2.U2 = (value2.U2 << 1) + num6;
                if (value2.U2 <= value3.U2 && (value2.U2 != value3.U2 || (value2.Low64 <= value3.Low64 && (value2.Low64 != value3.Low64 || (value.U0 & 1) == 0))))
                {
                    goto IL_03f3;
                }
            }
            goto IL_046a;
            IL_03f3:
            if (flag)
            {
                uint low2 = value.U0;
                ulong high = value.High64;
                Unscale(ref low2, ref high, ref scale);
                d1.Low = low2;
                d1.Mid = (uint)high;
                d1.High = (uint)(high >> 32);
            }
            else
            {
                d1.Low64 = value.Low64;
                d1.High = value.U2;
            }
            d1.uflags = ((d1.uflags ^ d2.uflags) & 0x80000000u) | (uint)(scale << 16);
            return;
            IL_046a:
            if (++value.Low64 == 0L && ++value.U2 == 0)
            {
                scale = OverflowUnscale(ref value, scale, sticky: true);
            }
            goto IL_03f3;
            IL_04ab:
            Number.ThrowOverflowException(TypeCode.Decimal);
            return;
            IL_01e8:
            ulong low3 = value2.Low64;
            if ((long)low3 >= 0L && (low3 <<= 1) <= num7 && (low3 != num7 || (value.U0 & 1) == 0))
            {
                goto IL_03f3;
            }
            goto IL_046a;
            IL_0090:
            num6 = num << 1;
            if (num6 >= num && (num6 < low || (num6 <= low && (value.U0 & 1) == 0)))
            {
                goto IL_03f3;
            }
            goto IL_046a;
        }

References System.Decimal.DecCalc.Add32To96(), System.Runtime.Serialization.Dictionary, System.Decimal.DecCalc.Div128By96(), System.Decimal.DecCalc.Div96By32(), System.Decimal.DecCalc.Div96By64(), System.Decimal.DecCalc.IncreaseScale(), System.Decimal.DecCalc.IncreaseScale64(), System.L, System.Numerics.BitOperations.LeadingZeroCount(), System.Math.Min(), System.Decimal.DecCalc.OverflowUnscale(), System.Decimal.DecCalc.s_powers10, System.Decimal.DecCalc.SearchScale(), System.Number.ThrowOverflowException(), System.Decimal.DecCalc.UInt32x32To64(), System.Decimal.DecCalc.Unscale(), and System.value.

Referenced by System.Decimal.Divide(), and System.Decimal.operator/().