DecAddSub()

static unsafe void System.Decimal.DecCalc.DecAddSub ( ref DecCalc d1, ref DecCalc d2, bool sign )

inlinestaticpackage

Definition at line 713 of file Decimal.cs.

        {
            ulong num = d1.Low64;
            uint num2 = d1.High;
            uint num3 = d1.uflags;
            uint num4 = d2.uflags;
            uint num5 = num4 ^ num3;
            sign ^= (num5 & 0x80000000u) != 0;
            int num7;
            if ((num5 & 0xFF0000u) != 0)
            {
                uint num6 = num3;
                num3 = (num4 & 0xFF0000u) | (num3 & 0x80000000u);
                num7 = (int)(num3 - num6) >> 16;
                if (num7 < 0)
                {
                    num7 = -num7;
                    num3 = num6;
                    if (sign)
                    {
                        num3 ^= 0x80000000u;
                    }
                    num = d2.Low64;
                    num2 = d2.High;
                    d2 = d1;
                }
                if (num2 != 0)
                {
                    goto IL_015f;
                }
                if (num > uint.MaxValue)
                {
                    goto IL_0106;
                }
                if ((int)num == 0)
                {
                    uint num8 = num3 & 0x80000000u;
                    if (sign)
                    {
                        num8 ^= 0x80000000u;
                    }
                    d1 = d2;
                    d1.uflags = (d2.uflags & 0xFF0000u) | num8;
                    return;
                }
                while (num7 > 9)
                {
                    num7 -= 9;
                    num = UInt32x32To64((uint)num, 1000000000u);
                    if (num <= uint.MaxValue)
                    {
                        continue;
                    }
                    goto IL_0106;
                }
                num = UInt32x32To64((uint)num, s_powers10[num7]);
            }
            goto IL_0450;
            IL_0106:
            ulong num10;
            while (true)
            {
                uint b = 1000000000u;
                if (num7 < 9)
                {
                    b = s_powers10[num7];
                }
                ulong num9 = UInt32x32To64((uint)num, b);
                num10 = UInt32x32To64((uint)(num >> 32), b) + (num9 >> 32);
                num = (uint)num9 + (num10 << 32);
                num2 = (uint)(num10 >> 32);
                if ((num7 -= 9) <= 0)
                {
                    break;
                }
                if (num2 == 0)
                {
                    continue;
                }
                goto IL_015f;
            }
            goto IL_0450;
            IL_0350:
            Buf24 value;
            value.Low64 = num;
            value.U2 = num2;
            uint num11;
            num7 = ScaleResult(&value, num11, (byte)(num3 >> 16));
            num3 = (num3 & 0xFF00FFFFu) | (uint)(num7 << 16);
            num = value.Low64;
            num2 = value.U2;
            goto IL_04b9;
            IL_015f:
            while (true)
            {
                uint b = 1000000000u;
                if (num7 < 9)
                {
                    b = s_powers10[num7];
                }
                ulong num9 = UInt32x32To64((uint)num, b);
                num10 = UInt32x32To64((uint)(num >> 32), b) + (num9 >> 32);
                num = (uint)num9 + (num10 << 32);
                num10 >>= 32;
                num10 += UInt32x32To64(num2, b);
                num7 -= 9;
                if (num10 > uint.MaxValue)
                {
                    break;
                }
                num2 = (uint)num10;
                if (num7 > 0)
                {
                    continue;
                }
                goto IL_0450;
            }
            Unsafe.SkipInit<Buf24>(out value);
            value.Low64 = num;
            value.Mid64 = num10;
            num11 = 3u;
            while (num7 > 0)
            {
                uint b = 1000000000u;
                if (num7 < 9)
                {
                    b = s_powers10[num7];
                }
                num10 = 0uL;
                uint* ptr = (uint*)(&value);
                uint num12 = 0u;
                do
                {
                    num10 += UInt32x32To64(ptr[num12], b);
                    ptr[num12] = (uint)num10;
                    num12++;
                    num10 >>= 32;
                }
                while (num12 <= num11);
                if ((uint)num10 != 0)
                {
                    ptr[++num11] = (uint)num10;
                }
                num7 -= 9;
            }
            num10 = value.Low64;
            num = d2.Low64;
            uint u = value.U2;
            num2 = d2.High;
            if (sign)
            {
                num = num10 - num;
                num2 = u - num2;
                if (num > num10)
                {
                    num2--;
                    if (num2 >= u)
                    {
                        goto IL_02b3;
                    }
                }
                else if (num2 > u)
                {
                    goto IL_02b3;
                }
            }
            else
            {
                num += num10;
                num2 += u;
                if (num < num10)
                {
                    num2++;
                    if (num2 <= u)
                    {
                        goto IL_0312;
                    }
                }
                else if (num2 < u)
                {
                    goto IL_0312;
                }
            }
            goto IL_0350;
            IL_0312:
            uint* ptr2 = (uint*)(&value);
            uint num13 = 3u;
            while (++ptr2[num13++] == 0)
            {
                if (num11 < num13)
                {
                    ptr2[num13] = 1u;
                    num11 = num13;
                    break;
                }
            }
            goto IL_0350;
            IL_0450:
            ulong num14 = num;
            uint num15 = num2;
            if (sign)
            {
                num = num14 - d2.Low64;
                num2 = num15 - d2.High;
                if (num > num14)
                {
                    num2--;
                    if (num2 >= num15)
                    {
                        goto IL_0394;
                    }
                }
                else if (num2 > num15)
                {
                    goto IL_0394;
                }
            }
            else
            {
                num = num14 + d2.Low64;
                num2 = num15 + d2.High;
                if (num < num14)
                {
                    num2++;
                    if (num2 <= num15)
                    {
                        goto IL_03b1;
                    }
                }
                else if (num2 < num15)
                {
                    goto IL_03b1;
                }
            }
            goto IL_04b9;
            IL_04b9:
            d1.uflags = num3;
            d1.High = num2;
            d1.Low64 = num;
            return;
            IL_0394:
            num3 ^= 0x80000000u;
            num2 = ~num2;
            num = 0L - num;
            if (num == 0L)
            {
                num2++;
            }
            goto IL_04b9;
            IL_02b3:
            uint* ptr3 = (uint*)(&value);
            uint num16 = 3u;
            while (ptr3[num16++]-- == 0)
            {
            }
            if (ptr3[num11] != 0 || --num11 > 2)
            {
                goto IL_0350;
            }
            goto IL_04b9;
            IL_03b1:
            if ((num3 & 0xFF0000) == 0)
            {
                Number.ThrowOverflowException(TypeCode.Decimal);
            }
            num3 -= 65536;
            ulong num17 = (ulong)num2 + 4294967296uL;
            num2 = (uint)(num17 / 10);
            num17 = (num17 - num2 * 10 << 32) + (num >> 32);
            uint num18 = (uint)(num17 / 10);
            num17 = (num17 - num18 * 10 << 32) + (uint)num;
            num = num18;
            num <<= 32;
            num18 = (uint)(num17 / 10);
            num += num18;
            num18 = (uint)(int)num17 - num18 * 10;
            if (num18 >= 5 && (num18 > 5 || (num & 1) != 0L) && ++num == 0L)
            {
                num2++;
            }
            goto IL_04b9;
        }

References System.Runtime.Serialization.Dictionary, System.L, System.Decimal.DecCalc.s_powers10, System.Decimal.DecCalc.ScaleResult(), System.Number.ThrowOverflowException(), System.Decimal.DecCalc.UInt32x32To64(), and System.value.

Referenced by System.Decimal.Add(), System.Decimal.operator+(), System.Decimal.operator-(), and System.Decimal.Subtract().