VarDecMod()

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

inlinestaticpackage

Definition at line 1767 of file Decimal.cs.

        {
            if ((d2.ulo | d2.umid | d2.uhi) == 0)
            {
                throw new DivideByZeroException();
            }
            if ((d1.ulo | d1.umid | d1.uhi) == 0)
            {
                return;
            }
            d2.uflags = (d2.uflags & 0x7FFFFFFFu) | (d1.uflags & 0x80000000u);
            int num = VarDecCmpSub(in Unsafe.As<DecCalc, decimal>(ref d1), in Unsafe.As<DecCalc, decimal>(ref d2));
            if (num == 0)
            {
                d1.ulo = 0u;
                d1.umid = 0u;
                d1.uhi = 0u;
                if (d2.uflags > d1.uflags)
                {
                    d1.uflags = d2.uflags;
                }
            }
            else
            {
                if ((int)((uint)num ^ (d1.uflags & 0x80000000u)) < 0)
                {
                    return;
                }
                int num2 = (sbyte)(d1.uflags - d2.uflags >> 16);
                if (num2 > 0)
                {
                    do
                    {
                        uint num3 = ((num2 >= 9) ? 1000000000u : s_powers10[num2]);
                        ulong num4 = UInt32x32To64(d2.Low, num3);
                        d2.Low = (uint)num4;
                        num4 >>= 32;
                        num4 += (d2.Mid + ((ulong)d2.High << 32)) * num3;
                        d2.Mid = (uint)num4;
                        d2.High = (uint)(num4 >> 32);
                    }
                    while ((num2 -= 9) > 0);
                    num2 = 0;
                }
                do
                {
                    if (num2 < 0)
                    {
                        d1.uflags = d2.uflags;
                        Unsafe.SkipInit<Buf12>(out var value);
                        value.Low64 = d1.Low64;
                        value.U2 = d1.High;
                        uint num6;
                        do
                        {
                            int num5 = SearchScale(ref value, 28 + num2);
                            if (num5 == 0)
                            {
                                break;
                            }
                            num6 = ((num5 >= 9) ? 1000000000u : s_powers10[num5]);
                            num2 += num5;
                            ulong num7 = UInt32x32To64(value.U0, num6);
                            value.U0 = (uint)num7;
                            num7 >>= 32;
                            value.High64 = num7 + value.High64 * num6;
                        }
                        while (num6 == 1000000000 && num2 < 0);
                        d1.Low64 = value.Low64;
                        d1.High = value.U2;
                    }
                    if (d1.High == 0)
                    {
                        d1.Low64 %= d2.Low64;
                        break;
                    }
                    if ((d2.High | d2.Mid) == 0)
                    {
                        uint low = d2.Low;
                        ulong num8 = ((ulong)d1.High << 32) | d1.Mid;
                        num8 = (num8 % low << 32) | d1.Low;
                        d1.Low64 = num8 % low;
                        d1.High = 0u;
                        continue;
                    }
                    VarDecModFull(ref d1, ref d2, num2);
                    break;
                }
                while (num2 < 0);
            }
        }

References System.Runtime.Serialization.Dictionary, System.Decimal.DecCalc.Buf12.Low64, System.Decimal.DecCalc.s_powers10, System.Decimal.DecCalc.SearchScale(), System.Decimal.DecCalc.UInt32x32To64(), System.value, System.Decimal.DecCalc.VarDecCmpSub(), and System.Decimal.DecCalc.VarDecModFull().

Referenced by System.Decimal.operator%(), and System.Decimal.Remainder().