NumberToStringFormat()

static unsafe void System.Number.NumberToStringFormat ( ref ValueStringBuilder sb, ref NumberBuffer number, ReadOnlySpan< char > format, NumberFormatInfo info )

inlinestaticpackage

Definition at line 2817 of file Number.cs.

    {
        int num = 0;
        byte* digitsPointer = number.GetDigitsPointer();
        int num2 = FindSection(format, (*digitsPointer == 0) ? 2 : (number.IsNegative ? 1 : 0));
        int num3;
        int num4;
        bool flag;
        bool flag2;
        int num5;
        int num6;
        int num9;
        while (true)
        {
            num3 = 0;
            num4 = -1;
            num5 = int.MaxValue;
            num6 = 0;
            flag = false;
            int num7 = -1;
            flag2 = false;
            int num8 = 0;
            num9 = num2;
            fixed (char* ptr = &MemoryMarshal.GetReference(format))
            {
                char c;
                while (num9 < format.Length && (c = ptr[num9++]) != 0)
                {
                    switch (c)
                    {
                    case ';':
                        break;
                    case '#':
                        num3++;
                        continue;
                    case '0':
                        if (num5 == int.MaxValue)
                        {
                            num5 = num3;
                        }
                        num3++;
                        num6 = num3;
                        continue;
                    case '.':
                        if (num4 < 0)
                        {
                            num4 = num3;
                        }
                        continue;
                    case ',':
                        if (num3 <= 0 || num4 >= 0)
                        {
                            continue;
                        }
                        if (num7 >= 0)
                        {
                            if (num7 == num3)
                            {
                                num++;
                                continue;
                            }
                            flag2 = true;
                        }
                        num7 = num3;
                        num = 1;
                        continue;
                    case '%':
                        num8 += 2;
                        continue;
                    case '‰':
                        num8 += 3;
                        continue;
                    case '"':
                    case '\'':
                        while (num9 < format.Length && ptr[num9] != 0 && ptr[num9++] != c)
                        {
                        }
                        continue;
                    case '\\':
                        if (num9 < format.Length && ptr[num9] != 0)
                        {
                            num9++;
                        }
                        continue;
                    case 'E':
                    case 'e':
                        if ((num9 < format.Length && ptr[num9] == '0') || (num9 + 1 < format.Length && (ptr[num9] == '+' || ptr[num9] == '-') && ptr[num9 + 1] == '0'))
                        {
                            while (++num9 < format.Length && ptr[num9] == '0')
                            {
                            }
                            flag = true;
                        }
                        continue;
                    default:
                        continue;
                    }
                    break;
                }
            }
            if (num4 < 0)
            {
                num4 = num3;
            }
            if (num7 >= 0)
            {
                if (num7 == num4)
                {
                    num8 -= num * 3;
                }
                else
                {
                    flag2 = true;
                }
            }
            if (*digitsPointer != 0)
            {
                number.Scale += num8;
                int pos = (flag ? num3 : (number.Scale + num3 - num4));
                RoundNumber(ref number, pos, isCorrectlyRounded: false);
                if (*digitsPointer != 0)
                {
                    break;
                }
                num9 = FindSection(format, 2);
                if (num9 == num2)
                {
                    break;
                }
                num2 = num9;
                continue;
            }
            if (number.Kind != NumberBufferKind.FloatingPoint)
            {
                number.IsNegative = false;
            }
            number.Scale = 0;
            break;
        }
        num5 = ((num5 < num4) ? (num4 - num5) : 0);
        num6 = ((num6 > num4) ? (num4 - num6) : 0);
        int num10;
        int num11;
        if (flag)
        {
            num10 = num4;
            num11 = 0;
        }
        else
        {
            num10 = ((number.Scale > num4) ? number.Scale : num4);
            num11 = number.Scale - num4;
        }
        num9 = num2;
        Span<int> span = stackalloc int[4];
        int num12 = -1;
        if (flag2 && info.NumberGroupSeparator.Length > 0)
        {
            int[] numberGroupSizes = info._numberGroupSizes;
            int num13 = 0;
            int i = 0;
            int num14 = numberGroupSizes.Length;
            if (num14 != 0)
            {
                i = numberGroupSizes[num13];
            }
            int num15 = i;
            int num16 = num10 + ((num11 < 0) ? num11 : 0);
            for (int num17 = ((num5 > num16) ? num5 : num16); num17 > i; i += num15)
            {
                if (num15 == 0)
                {
                    break;
                }
                num12++;
                if (num12 >= span.Length)
                {
                    int[] array = new int[span.Length * 2];
                    span.CopyTo(array);
                    span = array;
                }
                span[num12] = i;
                if (num13 < num14 - 1)
                {
                    num13++;
                    num15 = numberGroupSizes[num13];
                }
            }
        }
        if (number.IsNegative && num2 == 0 && number.Scale != 0)
        {
            sb.Append(info.NegativeSign);
        }
        bool flag3 = false;
        fixed (char* ptr3 = &MemoryMarshal.GetReference(format))
        {
            byte* ptr2 = digitsPointer;
            char c;
            while (num9 < format.Length && (c = ptr3[num9++]) != 0 && c != ';')
            {
                if (num11 > 0 && (c == '#' || c == '.' || c == '0'))
                {
                    while (num11 > 0)
                    {
                        sb.Append((char)((*ptr2 != 0) ? (*(ptr2++)) : 48));
                        if (flag2 && num10 > 1 && num12 >= 0 && num10 == span[num12] + 1)
                        {
                            sb.Append(info.NumberGroupSeparator);
                            num12--;
                        }
                        num10--;
                        num11--;
                    }
                }
                switch (c)
                {
                case '#':
                case '0':
                    if (num11 < 0)
                    {
                        num11++;
                        c = ((num10 <= num5) ? '0' : '\0');
                    }
                    else
                    {
                        c = ((*ptr2 != 0) ? ((char)(*(ptr2++))) : ((num10 > num6) ? '0' : '\0'));
                    }
                    if (c != 0)
                    {
                        sb.Append(c);
                        if (flag2 && num10 > 1 && num12 >= 0 && num10 == span[num12] + 1)
                        {
                            sb.Append(info.NumberGroupSeparator);
                            num12--;
                        }
                    }
                    num10--;
                    break;
                case '.':
                    if (!(num10 != 0 || flag3) && (num6 < 0 || (num4 < num3 && *ptr2 != 0)))
                    {
                        sb.Append(info.NumberDecimalSeparator);
                        flag3 = true;
                    }
                    break;
                case '‰':
                    sb.Append(info.PerMilleSymbol);
                    break;
                case '%':
                    sb.Append(info.PercentSymbol);
                    break;
                case '"':
                case '\'':
                    while (num9 < format.Length && ptr3[num9] != 0 && ptr3[num9] != c)
                    {
                        sb.Append(ptr3[num9++]);
                    }
                    if (num9 < format.Length && ptr3[num9] != 0)
                    {
                        num9++;
                    }
                    break;
                case '\\':
                    if (num9 < format.Length && ptr3[num9] != 0)
                    {
                        sb.Append(ptr3[num9++]);
                    }
                    break;
                case 'E':
                case 'e':
                {
                    bool positiveSign = false;
                    int num18 = 0;
                    if (flag)
                    {
                        if (num9 < format.Length && ptr3[num9] == '0')
                        {
                            num18++;
                        }
                        else if (num9 + 1 < format.Length && ptr3[num9] == '+' && ptr3[num9 + 1] == '0')
                        {
                            positiveSign = true;
                        }
                        else if (num9 + 1 >= format.Length || ptr3[num9] != '-' || ptr3[num9 + 1] != '0')
                        {
                            sb.Append(c);
                            break;
                        }
                        while (++num9 < format.Length && ptr3[num9] == '0')
                        {
                            num18++;
                        }
                        if (num18 > 10)
                        {
                            num18 = 10;
                        }
                        int value = ((*digitsPointer != 0) ? (number.Scale - num4) : 0);
                        FormatExponent(ref sb, info, value, c, num18, positiveSign);
                        flag = false;
                        break;
                    }
                    sb.Append(c);
                    if (num9 < format.Length)
                    {
                        if (ptr3[num9] == '+' || ptr3[num9] == '-')
                        {
                            sb.Append(ptr3[num9++]);
                        }
                        while (num9 < format.Length && ptr3[num9] == '0')
                        {
                            sb.Append(ptr3[num9++]);
                        }
                    }
                    break;
                }
                default:
                    sb.Append(c);
                    break;
                case ',':
                    break;
                }
            }
        }
        if (number.IsNegative && num2 == 0 && number.Scale == 0 && sb.Length > 0)
        {
            sb.Insert(0, info.NegativeSign);
        }
    }

References System.array, System.Span< T >.CopyTo(), System.Number.FindSection(), System.format, System.Number.FormatExponent(), System.info, System.Span< T >.Length, System.Number.RoundNumber(), and System.value.

Referenced by System.Number.FormatDecimal(), System.Number.FormatDouble(), System.Number.FormatHalf(), System.Number.FormatInt32(), System.Number.FormatInt64(), System.Number.FormatSingle(), System.Number.FormatUInt32(), System.Number.FormatUInt64(), System.Number.TryFormatDecimal(), System.Number.TryFormatInt32(), System.Number.TryFormatInt64(), System.Number.TryFormatUInt32(), and System.Number.TryFormatUInt64().