Format/Parse binary from/to BigInteger

src/libraries/Common/src/System/Globalization/FormatProvider.Number.cs

@@ -356,7 +356,54 @@ private static unsafe bool AllowHyphenDuringParsing(NumberFormatInfo info)
                 return ret;
             }
 
+            private interface IDigitValidator
+            {
+                static abstract bool IsValidChar(char c);
+                static abstract bool IsHexBinary();
+            }
+
+            private readonly struct IntegerDigitValidator : IDigitValidator
+            {
+                public static bool IsValidChar(char c) => char.IsAsciiDigit(c);
+
+                public static bool IsHexBinary() => false;
+            }
+
+            private readonly struct HexDigitValidator : IDigitValidator
+            {
+                public static bool IsValidChar(char c) => char.IsAsciiHexDigit(c);
+
+                public static bool IsHexBinary() => true;
+            }
+
+            private readonly struct BinaryDigitValidator : IDigitValidator
+            {
+                public static bool IsValidChar(char c)
+                {
+                    return c is '0' or '1';
+                }
+
+                public static bool IsHexBinary() => true;
+            }
+
+
             private static unsafe bool ParseNumber(ref char* str, char* strEnd, NumberStyles options, scoped ref NumberBuffer number, StringBuilder? sb, NumberFormatInfo numfmt, bool parseDecimal)
+            {
+                if ((options & NumberStyles.AllowHexSpecifier) != 0)
+                {
+                    return ParseNumberStyle<HexDigitValidator>(ref str, strEnd, options, ref number, sb, numfmt, parseDecimal);
+                }
+
+                if ((options & NumberStyles.AllowBinarySpecifier) != 0)
+                {
+                    return ParseNumberStyle<BinaryDigitValidator>(ref str, strEnd, options, ref number, sb, numfmt, parseDecimal);
+                }
+
+                return ParseNumberStyle<IntegerDigitValidator>(ref str, strEnd, options, ref number, sb, numfmt, parseDecimal);
+            }
+
+            private static unsafe bool ParseNumberStyle<TDigitValidator>(ref char* str, char* strEnd, NumberStyles options, scoped ref NumberBuffer number, StringBuilder? sb, NumberFormatInfo numfmt, bool parseDecimal)
+                where TDigitValidator : struct, IDigitValidator
             {
                 Debug.Assert(str != null);
                 Debug.Assert(strEnd != null);
@@ -440,11 +487,11 @@ private static unsafe bool ParseNumber(ref char* str, char* strEnd, NumberStyles
                 int digEnd = 0;
                 while (true)
                 {
-                    if (char.IsAsciiDigit(ch) || (((options & NumberStyles.AllowHexSpecifier) != 0) && char.IsBetween((char)(ch | 0x20), 'a', 'f')))
+                    if (TDigitValidator.IsValidChar(ch))
                     {
                         state |= StateDigits;
 
-                        if (ch != '0' || (state & StateNonZero) != 0 || (bigNumber && ((options & NumberStyles.AllowHexSpecifier) != 0)))
+                        if (ch != '0' || (state & StateNonZero) != 0 || (bigNumber && TDigitValidator.IsHexBinary()))
                         {
                             if (digCount < maxParseDigits)
                             {

src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs

@@ -285,7 +285,8 @@ internal static class BigNumber
                                                            | NumberStyles.AllowLeadingSign | NumberStyles.AllowTrailingSign
                                                            | NumberStyles.AllowParentheses | NumberStyles.AllowDecimalPoint
                                                            | NumberStyles.AllowThousands | NumberStyles.AllowExponent
-                                                           | NumberStyles.AllowCurrencySymbol | NumberStyles.AllowHexSpecifier);
+                                                           | NumberStyles.AllowCurrencySymbol | NumberStyles.AllowHexSpecifier
+                                                           | NumberStyles.AllowBinarySpecifier);
 
         private static ReadOnlySpan<uint> UInt32PowersOfTen => new uint[] { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
 
@@ -371,10 +372,13 @@ internal static ParsingStatus TryParseBigInteger(ReadOnlySpan<char> value, Numbe
             {
                 return HexNumberToBigInteger(ref bigNumber, out result);
             }
-            else
+
+            if ((style & NumberStyles.AllowBinarySpecifier) != 0)
             {
-                return NumberToBigInteger(ref bigNumber, out result);
+                return BinNumberToBigInteger(ref bigNumber, out result);
             }
+
+            return NumberToBigInteger(ref bigNumber, out result);
         }
 
         internal static BigInteger ParseBigInteger(string value, NumberStyles style, NumberFormatInfo info)
@@ -511,6 +515,96 @@ private static ParsingStatus HexNumberToBigInteger(ref BigNumberBuffer number, o
             }
         }
 
+        private static ParsingStatus BinNumberToBigInteger(ref BigNumberBuffer number, out BigInteger result)
+        {
+            if (number.digits is null || number.digits.Length < 2)
+            {
+                result = default;
+                return ParsingStatus.Failed;
+            }
+
+            const int DigitsPerBlock = 32;
+
+            int totalDigitCount = number.digits.Length - 1;   // Ignore trailing '\0'
+
+            int blockCount = Math.DivRem(totalDigitCount, DigitsPerBlock, out int remainingDigitsInBlock);
+            if (remainingDigitsInBlock == 0)
+            {
+                remainingDigitsInBlock = DigitsPerBlock;
+            }
+            else
+            {
+                blockCount++;
+            }
+
+            Debug.Assert(number.digits[0] is '0' or '1');
+            bool isNegative = number.digits[0] == '1';
+
+            uint[]? arrayFromPool = null;
+            Span<uint> bufferSpan = blockCount <= BigIntegerCalculator.StackAllocThreshold ?
+                stackalloc uint[blockCount] : (arrayFromPool = ArrayPool<uint>.Shared.Rent(blockCount)).AsSpan(0, blockCount);
+
+            try
+            {
+                uint currentBlock = isNegative ? 0xFF_FF_FF_FF : 0x0;
+                int bufferPos = blockCount;
+                foreach (ReadOnlyMemory<char> chunkMem in number.digits.GetChunks())
+                {
+                    ReadOnlySpan<char> chunk = chunkMem.Span;
+                    foreach (char c in chunk)
+                    {
+                        if (c == '\0')
+                        {
+                            break;
+                        }
+
+                        Debug.Assert(c is '0' or '1');
+                        currentBlock = (currentBlock << 1) | (uint)(c - '0');
+
+                        if (--remainingDigitsInBlock == 0)
+                        {
+                            bufferSpan[--bufferPos] = currentBlock;
+                            remainingDigitsInBlock = DigitsPerBlock;
+
+                            // we do not need to reset currentBlock now, because it should always set all its bits by left shift in subsequent iterations
+                        }
+                    }
+
+                    Debug.Assert(bufferPos > 0 || remainingDigitsInBlock == DigitsPerBlock);
+                }
+
+                Debug.Assert(bufferPos == 0 && remainingDigitsInBlock == DigitsPerBlock);
+
+                if (isNegative)
+                {
+                    NumericsHelpers.DangerousMakeTwosComplement(bufferSpan);
+                }
+
+                bufferSpan = bufferSpan.TrimEnd(0u);
+                if (bufferSpan.IsEmpty)
+                {
+                    result = BigInteger.Zero;
+                }
+                else if (bufferSpan.Length == 1 && bufferSpan[0] <= int.MaxValue)
+                {
+                    result = new BigInteger((int)(isNegative ? -bufferSpan[0] : bufferSpan[0]), (uint[]?)null);
+                }
+                else
+                {
+                    result = new BigInteger(isNegative ? -1 : 1, bufferSpan.ToArray());
+                }
+
+                return ParsingStatus.OK;
+            }
+            finally
+            {
+                if (arrayFromPool is not null)
+                {
+                    ArrayPool<uint>.Shared.Return(arrayFromPool);
+                }
+            }
+        }
+
         //
         // This threshold is for choosing the algorithm to use based on the number of digits.
         //
@@ -1002,6 +1096,103 @@ internal static char ParseFormatSpecifier(ReadOnlySpan<char> format, out int dig
             }
         }
 
+        private static string? FormatBigIntegerToBin(bool targetSpan, BigInteger value, int digits, Span<char> destination, out int charsWritten, out bool spanSuccess)
+        {
+            // Get the bytes that make up the BigInteger.
+            byte[]? arrayToReturnToPool = null;
+            Span<byte> bytes = stackalloc byte[64]; // arbitrary threshold
+            if (!value.TryWriteOrCountBytes(bytes, out int bytesWrittenOrNeeded))
+            {
+                bytes = arrayToReturnToPool = ArrayPool<byte>.Shared.Rent(bytesWrittenOrNeeded);
+                bool success = value.TryWriteBytes(bytes, out _);
+                Debug.Assert(success);
+            }
+            bytes = bytes.Slice(0, bytesWrittenOrNeeded);
+
+            Debug.Assert(!bytes.IsEmpty);
+
+            byte highByte = bytes[^1];
+
+            int charsInHighByte = 9 - byte.LeadingZeroCount(value._sign >= 0 ? highByte : (byte)~highByte);
+            long tmpCharCount = charsInHighByte + ((long)(bytes.Length - 1) << 3);
+
+            if (tmpCharCount > Array.MaxLength)
+            {
+                Debug.Assert(arrayToReturnToPool is not null);
+                ArrayPool<byte>.Shared.Return(arrayToReturnToPool);
+
+                throw new FormatException(SR.Format_TooLarge);
+            }
+
+            int charsForBits = (int)tmpCharCount;
+
+            Debug.Assert(digits < Array.MaxLength);
+            int charsIncludeDigits = Math.Max(digits, charsForBits);
+
+            try
+            {
+                scoped ValueStringBuilder sb;
+                if (targetSpan)
+                {
+                    if (charsIncludeDigits > destination.Length)
+                    {
+                        charsWritten = 0;
+                        spanSuccess = false;
+                        return null;
+                    }
+
+                    // Because we have ensured destination can take actual char length, so now just use ValueStringBuilder as wrapper so that subsequent logic can be reused by 2 flows (targetSpan and non-targetSpan);
+                    // meanwhile there is no need to copy to destination again after format data for targetSpan flow.
+                    sb = new ValueStringBuilder(destination);
+                }
+                else
+                {
+                    // each byte is typically eight chars
+                    sb = charsIncludeDigits > 512 ? new ValueStringBuilder(charsIncludeDigits) : new ValueStringBuilder(stackalloc char[charsIncludeDigits]);
+                }
+
+                if (digits > charsForBits)
+                {
+                    sb.Append(value._sign >= 0 ? '0' : '1', digits - charsForBits);
+                }
+
+                AppendByte(ref sb, highByte, charsInHighByte - 1);
+
+                for (int i = bytes.Length - 2; i >= 0; i--)
+                {
+                    AppendByte(ref sb, bytes[i]);
+                }
+
+                Debug.Assert(sb.Length == charsIncludeDigits);
+
+                if (targetSpan)
+                {
+                    charsWritten = charsIncludeDigits;
+                    spanSuccess = true;
+                    return null;
+                }
+
+                charsWritten = 0;
+                spanSuccess = false;
+                return sb.ToString();
+            }
+            finally
+            {
+                if (arrayToReturnToPool is not null)
+                {
+                    ArrayPool<byte>.Shared.Return(arrayToReturnToPool);
+                }
+            }
+
+            static void AppendByte(ref ValueStringBuilder sb, byte b, int startHighBit = 7)
+            {
+                for (int i = startHighBit; i >= 0; i--)
+                {
+                    sb.Append((char)('0' + ((b >> i) & 0x1)));
+                }
+            }
+        }
+
         internal static string FormatBigInteger(BigInteger value, string? format, NumberFormatInfo info)
         {
             return FormatBigInteger(targetSpan: false, value, format, format, info, default, out _, out _)!;
@@ -1026,7 +1217,10 @@ internal static bool TryFormatBigInteger(BigInteger value, ReadOnlySpan<char> fo
             {
                 return FormatBigIntegerToHex(targetSpan, value, fmt, digits, info, destination, out charsWritten, out spanSuccess);
             }
-
+            if (fmt == 'b' || fmt == 'B')
+            {
+                return FormatBigIntegerToBin(targetSpan, value, digits, destination, out charsWritten, out spanSuccess);
+            }
 
             if (value._bits == null)
             {