Sh-To-ERP-SYS-APP/Library/PackageCache/com.unity.burst@1.6.6/Runtime/BurstString.cs

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;

#if !BURST_COMPILER_SHARED
using Unity.Collections.LowLevel.Unsafe;
#endif

namespace Unity.Burst
{
#if BURST_COMPILER_SHARED
    internal static partial class BurstStringInternal
#else
    internal static partial class BurstString
#endif
    {
        /// <summary>
        /// Copies a Burst managed UTF8 string prefixed by a ushort length to a FixedString with the specified maximum length.
        /// </summary>
        /// <param name="dest">Pointer to the fixed string.</param>
        /// <param name="destLength">Maximum number of UTF8 the fixed string supports without including the zero character.</param>
        /// <param name="src">The UTF8 Burst managed string prefixed by a ushort length and zero terminated.
        /// <param name="srcLength">Number of UTF8 the fixed string supports without including the zero character.</param>
        /// </param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe void CopyFixedString(byte* dest, int destLength, byte* src, int srcLength)
        {
            // TODO: should we throw an exception instead if the string doesn't fit?
            var finalLength = srcLength > destLength ? destLength : srcLength;
            // Write the length and zero null terminated
            *((ushort*)dest - 1) = (ushort)finalLength;
            dest[finalLength] = 0;
#if BURST_COMPILER_SHARED
            Unsafe.CopyBlock(dest, src, (uint)finalLength);
#else
            UnsafeUtility.MemCpy(dest, src, finalLength);
#endif
        }

        /// <summary>
        /// Format a UTF-8 string (with a specified source length) to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="src">The source buffer of the string to copy from.</param>
        /// <param name="srcLength">The length of the string from the source buffer.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, byte* src, int srcLength, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;

            // Align left
            if (AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, srcLength)) return;

            int maxToCopy = destLength - destIndex;
            int toCopyLength = srcLength > maxToCopy ? maxToCopy : srcLength;
            if (toCopyLength > 0)
            {
#if BURST_COMPILER_SHARED
                Unsafe.CopyBlock(dest + destIndex, src, (uint)toCopyLength);
#else
                UnsafeUtility.MemCpy(dest + destIndex, src, toCopyLength);
#endif
                destIndex += toCopyLength;

                // Align right
                AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, srcLength);
            }
        }

        /// <summary>
        /// Format a float value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, float value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            ConvertFloatToString(dest, ref destIndex, destLength, value, options);
        }

        /// <summary>
        /// Format a double value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, double value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            ConvertDoubleToString(dest, ref destIndex, destLength, value, options);
        }

        /// <summary>
        /// Format a bool value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        [MethodImpl(MethodImplOptions.NoInlining)]
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, bool value, int formatOptionsRaw)
        {
            var length = value ? 4 : 5; // True = 4 chars, False = 5 chars
            var options = *(FormatOptions*)&formatOptionsRaw;

            // Align left
            if (AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, length)) return;

            if (value)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'T';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'r';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'u';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'e';
            }
            else
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'F';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'a';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'l';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'s';
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'e';
            }

            // Align right
            AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, length);
        }

        /// <summary>
        /// Format a char value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        [MethodImpl(MethodImplOptions.NoInlining)]
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, char value, int formatOptionsRaw)
        {
            var length = value <= 0x7f ? 1 : value <= 0x7FF ? 2 : 3;
            var options = *(FormatOptions*)&formatOptionsRaw;

            // Align left - Special case for char, make the length as it was always one byte (one char)
            // so that alignment is working fine (on a char basis)
            if (AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, 1)) return;

            // Basic encoding of UTF16 to UTF8, doesn't handle high/low surrogate as we are given only one char
            if (length == 1)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)value;
            }
            else if (length == 2)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)((value >> 6) | 0xC0);

                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)((value & 0x3F) | 0x80);
            }
            else if (length == 3)
            {
                // We don't handle high/low surrogate, so we replace the char with the replacement char
                // 0xEF, 0xBF, 0xBD
                bool isHighOrLowSurrogate = value >= '\xD800' && value <= '\xDFFF';
                if (isHighOrLowSurrogate)
                {
                    if (destIndex >= destLength) return;
                    dest[destIndex++] = 0xEF;

                    if (destIndex >= destLength) return;
                    dest[destIndex++] = 0xBF;

                    if (destIndex >= destLength) return;
                    dest[destIndex++] = 0xBD;
                }
                else
                {
                    if (destIndex >= destLength) return;
                    dest[destIndex++] = (byte)((value >> 12) | 0xE0);

                    if (destIndex >= destLength) return;
                    dest[destIndex++] = (byte)(((value >> 6) & 0x3F) | 0x80);

                    if (destIndex >= destLength) return;
                    dest[destIndex++] = (byte)((value & 0x3F) | 0x80);
                }
            }

            // Align right - Special case for char, make the length as it was always one byte (one char)
            // so that alignment is working fine (on a char basis)
            AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, 1);
        }

        /// <summary>
        /// Format a byte value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, byte value, int formatOptionsRaw)
        {
            Format(dest, ref destIndex, destLength, (ulong)value, formatOptionsRaw);
        }

        /// <summary>
        /// Format an ushort value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, ushort value, int formatOptionsRaw)
        {
            Format(dest, ref destIndex, destLength, (ulong)value, formatOptionsRaw);
        }

        /// <summary>
        /// Format an uint value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, uint value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, value, options);
        }

        /// <summary>
        /// Format a ulong value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, ulong value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, value, options);
        }

        /// <summary>
        /// Format a sbyte value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, sbyte value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            if (options.Kind == NumberFormatKind.Hexadecimal)
            {
                ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (byte)value, options);
            }
            else
            {
                ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
            }
        }

        /// <summary>
        /// Format a short value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, short value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            if (options.Kind == NumberFormatKind.Hexadecimal)
            {
                ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (ushort)value, options);
            }
            else
            {
                ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
            }

        }

        /// <summary>
        /// Format an int value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        [MethodImpl(MethodImplOptions.NoInlining)]
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, int value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            if (options.Kind == NumberFormatKind.Hexadecimal)
            {
                ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (uint)value, options);
            }
            else
            {
                ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
            }
        }

        /// <summary>
        /// Format a long value to a destination buffer.
        /// </summary>
        /// <param name="dest">Destination buffer.</param>
        /// <param name="destIndex">Current index in destination buffer.</param>
        /// <param name="destLength">Maximum length of destination buffer.</param>
        /// <param name="value">The value to format.</param>
        /// <param name="formatOptionsRaw">Formatting options encoded in raw format.</param>
        public static unsafe void Format(byte* dest, ref int destIndex, int destLength, long value, int formatOptionsRaw)
        {
            var options = *(FormatOptions*)&formatOptionsRaw;
            if (options.Kind == NumberFormatKind.Hexadecimal)
            {
                ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (ulong)value, options);
            }
            else
            {
                ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
            }
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static unsafe void ConvertUnsignedIntegerToString(byte* dest, ref int destIndex, int destLength, ulong value, FormatOptions options)
        {
            var basis = (uint)options.GetBase();
            if (basis < 2 || basis > 36) return;

            // Calculate the full length (including zero padding)
            int length = 0;
            var tmp = value;
            do
            {
                tmp /= basis;
                length++;
            } while (tmp != 0);

            // Write the characters for the numbers to a temp buffer
            int tmpIndex = length - 1;
            byte* tmpBuffer = stackalloc byte[length + 1];

            tmp = value;
            do
            {
                tmpBuffer[tmpIndex--] = ValueToIntegerChar((int)(tmp % basis), options.Uppercase);
                tmp /= basis;
            } while (tmp != 0);

            tmpBuffer[length] = 0;

            var numberBuffer = new NumberBuffer(NumberBufferKind.Integer, tmpBuffer, length, length, false);
            FormatNumber(dest, ref destIndex, destLength, ref numberBuffer, options.Specifier, options);
        }

        private static int GetLengthIntegerToString(long value, int basis, int zeroPadding)
        {
            int length = 0;
            var tmp = value;
            do
            {
                tmp /= basis;
                length++;
            } while (tmp != 0);

            if (length < zeroPadding)
            {
                length = zeroPadding;
            }

            if (value < 0) length++;
            return length;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static unsafe void ConvertIntegerToString(byte* dest, ref int destIndex, int destLength, long value, FormatOptions options)
        {
            var basis = options.GetBase();
            if (basis < 2 || basis > 36) return;

            // Calculate the full length (including zero padding)
            int length = 0;
            var tmp = value;
            do
            {
                tmp /= basis;
                length++;
            } while (tmp != 0);

            // Write the characters for the numbers to a temp buffer
            byte* tmpBuffer = stackalloc byte[length + 1];

            tmp = value;
            int tmpIndex = length - 1;
            do
            {
                tmpBuffer[tmpIndex--] = ValueToIntegerChar((int)(tmp % basis), options.Uppercase);
                tmp /= basis;
            } while (tmp != 0);
            tmpBuffer[length] = 0;

            var numberBuffer = new NumberBuffer(NumberBufferKind.Integer, tmpBuffer, length, length, value < 0);
            FormatNumber(dest, ref destIndex, destLength, ref numberBuffer, options.Specifier, options);
        }

        private static unsafe void FormatNumber(byte* dest, ref int destIndex, int destLength, ref NumberBuffer number, int nMaxDigits, FormatOptions options)
        {
            bool isCorrectlyRounded = (number.Kind == NumberBufferKind.Float);

            // If we have an integer, and the rendering is the default `G`, then use Decimal rendering which is faster
            if (number.Kind == NumberBufferKind.Integer && options.Kind == NumberFormatKind.General && options.Specifier == 0)
            {
                options.Kind = NumberFormatKind.Decimal;
            }

            int length;
            switch (options.Kind)
            {
                case NumberFormatKind.DecimalForceSigned:
                case NumberFormatKind.Decimal:
                case NumberFormatKind.Hexadecimal:
                    length = number.DigitsCount;

                    var zeroPadding = (int)options.Specifier;
                    int actualZeroPadding = 0;
                    if (length < zeroPadding)
                    {
                        actualZeroPadding = zeroPadding - length;
                        length = zeroPadding;
                    }

                    bool outputPositiveSign = options.Kind == NumberFormatKind.DecimalForceSigned;
                    length += number.IsNegative || outputPositiveSign ? 1 : 0;

                    // Perform left align
                    if (AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, length)) return;

                    FormatDecimalOrHexadecimal(dest, ref destIndex, destLength, ref number, actualZeroPadding, outputPositiveSign);

                    // Perform right align
                    AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, length);

                    break;

                default:
                case NumberFormatKind.General:

                    if (nMaxDigits < 1)
                    {
                        // This ensures that the PAL code pads out to the correct place even when we use the default precision
                        nMaxDigits = number.DigitsCount;
                    }

                    RoundNumber(ref number, nMaxDigits, isCorrectlyRounded);

                    // Calculate final rendering length
                    length = GetLengthForFormatGeneral(ref number, nMaxDigits);

                    // Perform left align
                    if (AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, length)) return;

                    // Format using general formatting
                    FormatGeneral(dest, ref destIndex, destLength, ref number, nMaxDigits, options.Uppercase ? (byte)'E' : (byte)'e');

                    // Perform right align
                    AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, length);
                    break;
            }
        }

        private static unsafe void FormatDecimalOrHexadecimal(byte* dest, ref int destIndex, int destLength, ref NumberBuffer number, int zeroPadding, bool outputPositiveSign)
        {
            if (number.IsNegative)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'-';
            }
            else if (outputPositiveSign)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'+';
            }

            // Zero Padding
            for (int i = 0; i < zeroPadding; i++)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'0';
            }

            var digitCount = number.DigitsCount;
            byte* digits = number.GetDigitsPointer();
            for (int i = 0; i < digitCount; i++)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = digits[i];
            }
        }

        private static byte ValueToIntegerChar(int value, bool uppercase)
        {
            value = value < 0 ? -value : value;
            if (value <= 9)
                return (byte)('0' + value);
            if (value < 36)
                return (byte)((uppercase ? 'A' : 'a') + (value - 10));

            return (byte)'?';
        }

        private static readonly char[] SplitByColon = new char[] { ':' };

#if !NET_DOTS
        private static void OptsSplit(string fullFormat, out string padding, out string format)
        {
            var split = fullFormat.Split(SplitByColon, StringSplitOptions.RemoveEmptyEntries);
            format = split[0];
            padding = null;
            if (split.Length == 2)
            {
                padding = format;
                format = split[1];
            }
            else if (split.Length == 1)
            {
                if (format[0] == ',')
                {
                    padding = format;
                    format = null;
                }
            }
            else
            {
                throw new ArgumentException($"Format `{format}` not supported. Invalid number {split.Length} of :. Expecting no more than one.");
            }
        }
#else
        // Tiny BCL is missing StringSplitOptions
        private static void OptsSplit(string fullFormat, out string padding, out string format)
        {
            var idx0 = 0;
            var idx1 = 1;
            var length = 0;
            var split = fullFormat.Split(SplitByColon);
            for (int chk=0;chk<split.Length;chk++)
            {
                if (split[chk].Length>0)
                    length++;
            }
            while (idx0<split.Length)
            {
                if (split[idx0].Length>0)
                {
                    idx1=idx0+1;
                    break;
                }

                idx0++;
            }
            while (idx1<split.Length)
            {
                if (split[idx1].Length>0)
                {
                    break;
                }

                idx1++;
            }
            format = split[idx0];
            padding = null;
            if (length == 2)
            {
                padding = format;
                format=split[idx1];
            }
            else if (length == 1)
            {
                if (format[0]==',')
                {
                    padding = format;
                    format = null;
                }
            }
            else
            {
                throw new ArgumentException($"Format `{format}` not supported. Invalid number {length} of :. Expecting no more than one.");
            }
        }
#endif

        /// <summary>
        /// Parse a format string as specified .NET string.Format https://docs.microsoft.com/en-us/dotnet/api/system.string.format?view=netframework-4.8
        /// - Supports only Left/Right Padding (e.g {0,-20} {0, 8})
        /// - 'G' 'g' General formatting for numbers with precision specifier (e.g G4 or g4)
        /// - 'D' 'd' General formatting for numbers with precision specifier (e.g D5 or d5)
        /// - 'X' 'x' General formatting for integers with precision specifier (e.g X8 or x8)
        /// </summary>
        /// <param name="fullFormat"></param>
        /// <returns></returns>
        public static FormatOptions ParseFormatToFormatOptions(string fullFormat)
        {
            if (string.IsNullOrWhiteSpace(fullFormat)) return new FormatOptions();

            OptsSplit(fullFormat, out var padding, out var format);

            format = format?.Trim();
            padding = padding?.Trim();

            int alignAndSize = 0;
            var formatKind = NumberFormatKind.General;
            bool lowercase = false;
            int specifier = 0;

            if (!string.IsNullOrEmpty(format))
            {
                switch (format[0])
                {
                    case 'G':
                        formatKind = NumberFormatKind.General;
                        break;
                    case 'g':
                        formatKind = NumberFormatKind.General;
                        lowercase = true;
                        break;
                    case 'D':
                        formatKind = NumberFormatKind.Decimal;
                        break;
                    case 'd':
                        formatKind = NumberFormatKind.Decimal;
                        lowercase = true;
                        break;
                    case 'X':
                        formatKind = NumberFormatKind.Hexadecimal;
                        break;
                    case 'x':
                        formatKind = NumberFormatKind.Hexadecimal;
                        lowercase = true;
                        break;
                    default:
                        throw new ArgumentException($"Format `{format}` not supported. Only G, g, D, d, X, x are supported.");
                }

                if (format.Length > 1)
                {
                    var specifierString = format.Substring(1);
#if !NET_DOTS
                    if (!uint.TryParse(specifierString, out var unsignedSpecifier))
#else
                    // Tiny BCL is missing string->uint
                    if (!ParseUnsigned(specifierString, out var unsignedSpecifier))
#endif
                    {
                        throw new ArgumentException($"Expecting an unsigned integer for specifier `{format}` instead of {specifierString}.");
                    }
                    specifier = (int)unsignedSpecifier;
                }
            }

            if (!string.IsNullOrEmpty(padding))
            {
                if (padding[0] != ',')
                {
                    throw new ArgumentException($"Invalid padding `{padding}`, expecting to start with a leading `,` comma.");
                }

                var numberStr = padding.Substring(1);
#if !NET_DOTS
                if (!int.TryParse(numberStr, out alignAndSize))
#else
                // Tiny BCL is missing string->int
                if (!ParseSigned(numberStr, out alignAndSize))
#endif
                {
                    throw new ArgumentException($"Expecting an integer for align/size padding `{numberStr}`.");
                }
            }

            return new FormatOptions(formatKind, (sbyte)alignAndSize, (byte)specifier, lowercase);
        }

#if NET_DOTS
        // Won't handle anything but simple ascii unsigned integers
        private static bool ParseUnsigned(string inputString, out uint unsignedValue, int startIdx = 0)
        {
            var length = inputString.Length;
            unsignedValue = 0;
            for (int i = startIdx; i < inputString.Length; i++)
            {
                var c = inputString[i];
                if (c>='0' && c<='9')
                {
                    if (unsignedValue>=0x19999999)    // overflow
                        return false;
                    unsignedValue*=10;
                    unsignedValue+=(uint)(c-'0');
                }
                else
                {
                    return false;
                }
            }

            return true;
        }

        // Won't handle anything but simple ascii signed integers
        private static bool ParseSigned(string inputString, out int signedValue)
        {
            signedValue = 0;
            int startIdx = 0;
            bool negative = false;
            if (inputString[0] == '-' || inputString[0] == '+')
            {
                negative = inputString[0] == '-';
                startIdx++;
            }

            if (!ParseUnsigned(inputString, out var unsignedValue, startIdx))
            {
                return false;
            }

            if (negative)
            {
                if (unsignedValue > 0x80000000)
                    return false;
                signedValue = (int) ((~unsignedValue) + 1);
            }
            else
            {
                if (unsignedValue > 0x7FFFFFFF)
                    return false;
                signedValue = (int) unsignedValue;
            }

            return true;
        }
#endif
        private static unsafe bool AlignRight(byte* dest, ref int destIndex, int destLength, int align, int length)
        {
            // right align
            if (align < 0)
            {
                align = -align;
                return AlignLeft(dest, ref destIndex, destLength, align, length);
            }

            return false;
        }

        private static unsafe bool AlignLeft(byte* dest, ref int destIndex, int destLength, int align, int length)
        {
            // left align
            if (align > 0)
            {
                while (length < align)
                {
                    if (destIndex >= destLength) return true;
                    dest[destIndex++] = (byte)' ';
                    length++;
                }
            }

            return false;
        }

        private static unsafe int GetLengthForFormatGeneral(ref NumberBuffer number, int nMaxDigits)
        {
            // NOTE: Must be kept in sync with FormatGeneral!
            int length = 0;
            int scale = number.Scale;
            int digPos = scale;
            bool scientific = false;

            // Don't switch to scientific notation
            if (digPos > nMaxDigits || digPos < -3)
            {
                digPos = 1;
                scientific = true;
            }

            byte* dig = number.GetDigitsPointer();

            if (number.IsNegative)
            {
                length++; // (byte)'-';
            }

            if (digPos > 0)
            {
                do
                {
                    if (*dig != 0)
                    {
                        dig++;
                    }
                    length++;
                } while (--digPos > 0);
            }
            else
            {
                length++;
            }

            if (*dig != 0 || digPos < 0)
            {
                length++; // (byte)'.';

                while (digPos < 0)
                {
                    length++; // (byte)'0';
                    digPos++;
                }

                while (*dig != 0)
                {
                    length++; // *dig++;
                    dig++;
                }
            }

            if (scientific)
            {
                length++; // e or E
                int exponent = number.Scale - 1;
                if (exponent >= 0) length++;
                length += GetLengthIntegerToString(exponent, 10, 2);
            }

            return length;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static unsafe void FormatGeneral(byte* dest, ref int destIndex, int destLength, ref NumberBuffer number, int nMaxDigits, byte expChar)
        {
            int scale = number.Scale;
            int digPos = scale;
            bool scientific = false;

            // Don't switch to scientific notation
            if (digPos > nMaxDigits || digPos < -3)
            {
                digPos = 1;
                scientific = true;
            }

            byte* dig = number.GetDigitsPointer();

            if (number.IsNegative)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'-';
            }

            if (digPos > 0)
            {
                do
                {
                    if (destIndex >= destLength) return;
                    dest[destIndex++] = (*dig != 0) ? (byte)(*dig++) : (byte)'0';
                } while (--digPos > 0);
            }
            else
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'0';
            }

            if (*dig != 0 || digPos < 0)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = (byte)'.';

                while (digPos < 0)
                {
                    if (destIndex >= destLength) return;
                    dest[destIndex++] = (byte)'0';
                    digPos++;
                }

                while (*dig != 0)
                {
                    if (destIndex >= destLength) return;
                    dest[destIndex++] = *dig++;
                }
            }

            if (scientific)
            {
                if (destIndex >= destLength) return;
                dest[destIndex++] = expChar;

                int exponent = number.Scale - 1;
                var exponentFormatOptions = new FormatOptions(NumberFormatKind.DecimalForceSigned, 0, 2, false);

                ConvertIntegerToString(dest, ref destIndex, destLength, exponent, exponentFormatOptions);
            }
        }

        private static unsafe void RoundNumber(ref NumberBuffer number, int pos, bool isCorrectlyRounded)
        {
            byte* dig = number.GetDigitsPointer();

            int i = 0;
            while (i < pos && dig[i] != (byte)'\0')
                i++;

            if ((i == pos) && ShouldRoundUp(dig, i, isCorrectlyRounded))
            {
                while (i > 0 && dig[i - 1] == (byte)'9')
                    i--;

                if (i > 0)
                {
                    dig[i - 1]++;
                }
                else
                {
                    number.Scale++;
                    dig[0] = (byte)('1');
                    i = 1;
                }
            }
            else
            {
                while (i > 0 && dig[i - 1] == (byte)'0')
                    i--;
            }

            if (i == 0)
            {
                number.Scale = 0;      // Decimals with scale ('0.00') should be rounded.
            }

            dig[i] = (byte)('\0');
            number.DigitsCount = i;
        }

        private static unsafe bool ShouldRoundUp(byte* dig, int i, bool isCorrectlyRounded)
        {
            // We only want to round up if the digit is greater than or equal to 5 and we are
            // not rounding a floating-point number. If we are rounding a floating-point number
            // we have one of two cases.
            //
            // In the case of a standard numeric-format specifier, the exact and correctly rounded
            // string will have been produced. In this scenario, pos will have pointed to the
            // terminating null for the buffer and so this will return false.
            //
            // However, in the case of a custom numeric-format specifier, we currently fall back
            // to generating Single/DoublePrecisionCustomFormat digits and then rely on this
            // function to round correctly instead. This can unfortunately lead to double-rounding
            // bugs but is the best we have right now due to back-compat concerns.

            byte digit = dig[i];

            if ((digit == '\0') || isCorrectlyRounded)
            {
                // Fast path for the common case with no rounding
                return false;
            }

            // Values greater than or equal to 5 should round up, otherwise we round down. The IEEE
            // 754 spec actually dictates that ties (exactly 5) should round to the nearest even number
            // but that can have undesired behavior for custom numeric format strings. This probably
            // needs further thought for .NET 5 so that we can be spec compliant and so that users
            // can get the desired rounding behavior for their needs.

            return digit >= '5';
        }

        private enum NumberBufferKind
        {
            Integer,
            Float,
        }

        /// <summary>
        /// Information about a number: pointer to digit buffer, scale and if negative.
        /// </summary>
        private unsafe struct NumberBuffer
        {
            private readonly byte* _buffer;

            public NumberBuffer(NumberBufferKind kind, byte* buffer, int digitsCount, int scale, bool isNegative)
            {
                Kind = kind;
                _buffer = buffer;
                DigitsCount = digitsCount;
                Scale = scale;
                IsNegative = isNegative;
            }

            public NumberBufferKind Kind;

            public int DigitsCount;

            public int Scale;

            public readonly bool IsNegative;

            public byte* GetDigitsPointer() => _buffer;
        }

        /// <summary>
        /// Type of formatting
        /// </summary>
        public enum NumberFormatKind : byte
        {
            /// <summary>
            /// General 'G' or 'g' formatting.
            /// </summary>
            General,

            /// <summary>
            /// Decimal 'D' or 'd' formatting.
            /// </summary>
            Decimal,

            /// <summary>
            /// Internal use only. Decimal 'D' or 'd' formatting with a `+` positive in front of the decimal if positive
            /// </summary>
            DecimalForceSigned,

            /// <summary>
            /// Hexadecimal 'X' or 'x' formatting.
            /// </summary>
            Hexadecimal,
        }

        /// <summary>
        /// Formatting options. Must be sizeof(int)
        /// </summary>
        public struct FormatOptions
        {
            public FormatOptions(NumberFormatKind kind, sbyte alignAndSize, byte specifier, bool lowercase) : this()
            {
                Kind = kind;
                AlignAndSize = alignAndSize;
                Specifier = specifier;
                Lowercase = lowercase;
            }

            public NumberFormatKind Kind;
            public sbyte AlignAndSize;
            public byte Specifier;
            public bool Lowercase;

            public bool Uppercase => !Lowercase;

            /// <summary>
            /// Encode this options to a single integer.
            /// </summary>
            /// <returns></returns>
            public unsafe int EncodeToRaw()
            {
#if !NET_DOTS
                Debug.Assert(sizeof(FormatOptions) == sizeof(int));
#endif
                var value = this;
                return *(int*)&value;
            }

            /// <summary>
            /// Get the base used for formatting this number.
            /// </summary>
            /// <returns></returns>
            public int GetBase()
            {
                switch (Kind)
                {
                    case NumberFormatKind.Hexadecimal:
                        return 16;
                    default:
                        return 10;
                }
            }

            public override string ToString()
            {
                return $"{nameof(Kind)}: {Kind}, {nameof(AlignAndSize)}: {AlignAndSize}, {nameof(Specifier)}: {Specifier}, {nameof(Uppercase)}: {Uppercase}";
            }
        }
    }
}