diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems index 16ba6ff21026e..29b8cda5cd196 100644 --- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems +++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems @@ -329,7 +329,7 @@ - + @@ -2599,4 +2599,4 @@ - + \ No newline at end of file diff --git a/src/libraries/System.Private.CoreLib/src/System/Convert.cs b/src/libraries/System.Private.CoreLib/src/System/Convert.cs index 880bc2f6599ef..0967438585c4e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Convert.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Convert.cs @@ -2099,7 +2099,7 @@ public static byte ToByte(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } if (value == null) @@ -2122,7 +2122,7 @@ public static sbyte ToSByte(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } if (value == null) @@ -2147,7 +2147,7 @@ public static short ToInt16(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } if (value == null) @@ -2173,7 +2173,7 @@ public static ushort ToUInt16(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } if (value == null) @@ -2195,7 +2195,7 @@ public static int ToInt32(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } return value != null ? ParseNumbers.StringToInt(value.AsSpan(), fromBase, ParseNumbers.IsTight) : @@ -2211,7 +2211,7 @@ public static uint ToUInt32(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } return value != null ? (uint)ParseNumbers.StringToInt(value.AsSpan(), fromBase, ParseNumbers.TreatAsUnsigned | ParseNumbers.IsTight) : @@ -2226,7 +2226,7 @@ public static long ToInt64(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } return value != null ? ParseNumbers.StringToLong(value.AsSpan(), fromBase, ParseNumbers.IsTight) : @@ -2242,7 +2242,7 @@ public static ulong ToUInt64(string? value, int fromBase) { if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16) { - throw new ArgumentException(SR.Arg_InvalidBase); + ThrowInvalidBase(); } return value != null ? (ulong)ParseNumbers.StringToLong(value.AsSpan(), fromBase, ParseNumbers.TreatAsUnsigned | ParseNumbers.IsTight) : @@ -2250,43 +2250,111 @@ public static ulong ToUInt64(string? value, int fromBase) } // Convert the byte value to a string in base fromBase - public static string ToString(byte value, int toBase) - { - if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) - { - throw new ArgumentException(SR.Arg_InvalidBase); - } - return ParseNumbers.IntToString((int)value, toBase, -1, ' ', ParseNumbers.PrintAsI1); - } + public static string ToString(byte value, int toBase) => + ToString((int)value, toBase); // Convert the Int16 value to a string in base fromBase public static string ToString(short value, int toBase) { - if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) + string format = "d"; + + switch (toBase) { - throw new ArgumentException(SR.Arg_InvalidBase); - } - return ParseNumbers.IntToString((int)value, toBase, -1, ' ', ParseNumbers.PrintAsI2); + case 2: + format = "b"; + break; + + case 8: + return ToOctalString((ushort)value); + + case 10: + break; + + case 16: + format = "x"; + break; + + default: + ThrowInvalidBase(); + break; + }; + + return value.ToString(format, CultureInfo.InvariantCulture); } // Convert the Int32 value to a string in base toBase public static string ToString(int value, int toBase) { - if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) + string format = "d"; + + switch (toBase) { - throw new ArgumentException(SR.Arg_InvalidBase); - } - return ParseNumbers.IntToString(value, toBase, -1, ' ', 0); + case 2: + format = "b"; + break; + + case 8: + return ToOctalString((uint)value); + + case 10: + break; + + case 16: + format = "x"; + break; + + default: + ThrowInvalidBase(); + break; + }; + + return value.ToString(format, CultureInfo.InvariantCulture); } // Convert the Int64 value to a string in base toBase public static string ToString(long value, int toBase) { - if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16) + string format = "d"; + + switch (toBase) { - throw new ArgumentException(SR.Arg_InvalidBase); + case 2: + format = "b"; + break; + + case 8: + return ToOctalString((ulong)value); + + case 10: + break; + + case 16: + format = "x"; + break; + + default: + ThrowInvalidBase(); + break; + }; + + return value.ToString(format, CultureInfo.InvariantCulture); + } + + private static void ThrowInvalidBase() => throw new ArgumentException(SR.Arg_InvalidBase); + + private static string ToOctalString(ulong value) + { + Span chars = stackalloc char[22]; // max length of a ulong in octal + + int i = chars.Length; + do + { + chars[--i] = (char)('0' + (value & 7)); + value >>= 3; } - return ParseNumbers.LongToString(value, toBase, -1, ' ', 0); + while (value != 0); + + return chars.Slice(i).ToString(); } public static string ToBase64String(byte[] inArray) diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs b/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs index 41db3a79f707c..0a4d1ceaf6584 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Number.Formatting.cs @@ -102,6 +102,13 @@ namespace System // left-padded with zeros to produce the number of digits given by the // precision specifier. // + // B b - Binary format. This format is + // supported for integral types only. The number is converted to a string of + // binary digits, '0' or '1'. The precision specifier indicates the minimum number + // of digits desired in the resulting string. If required, the number will be + // left-padded with zeros to produce the number of digits given by the + // precision specifier. + // // Some examples of standard format strings and their results are shown in the // table below. (The examples all assume a default NumberFormatInfo.) // @@ -934,6 +941,10 @@ static unsafe string FormatInt32Slow(int value, int hexMask, string? format, IFo { return Int32ToHexStr(value & hexMask, GetHexBase(fmt), digits); } + else if (fmtUpper == 'B') + { + return UInt32ToBinaryStr((uint)(value & hexMask), digits); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -989,6 +1000,10 @@ static unsafe bool TryFormatInt32Slow(int value, int hexMask, ReadOnlySpan { return TryInt32ToHexStr(value & hexMask, GetHexBase(fmt), digits, destination, out charsWritten); } + else if (fmtUpper == 'B') + { + return TryUInt32ToBinaryStr((uint)(value & hexMask), digits, destination, out charsWritten); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1040,6 +1055,10 @@ static unsafe string FormatUInt32Slow(uint value, string? format, IFormatProvide { return Int32ToHexStr((int)value, GetHexBase(fmt), digits); } + else if (fmtUpper == 'B') + { + return UInt32ToBinaryStr(value, digits); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1093,6 +1112,10 @@ static unsafe bool TryFormatUInt32Slow(uint value, ReadOnlySpan format, IF { return TryInt32ToHexStr((int)value, GetHexBase(fmt), digits, destination, out charsWritten); } + else if (fmtUpper == 'B') + { + return TryUInt32ToBinaryStr(value, digits, destination, out charsWritten); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1148,6 +1171,10 @@ static unsafe string FormatInt64Slow(long value, string? format, IFormatProvider { return Int64ToHexStr(value, GetHexBase(fmt), digits); } + else if (fmtUpper == 'B') + { + return UInt64ToBinaryStr((ulong)value, digits); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1205,6 +1232,10 @@ static unsafe bool TryFormatInt64Slow(long value, ReadOnlySpan format, IFo { return TryInt64ToHexStr(value, GetHexBase(fmt), digits, destination, out charsWritten); } + else if (fmtUpper == 'B') + { + return TryUInt64ToBinaryStr((ulong)value, digits, destination, out charsWritten); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1256,6 +1287,10 @@ static unsafe string FormatUInt64Slow(ulong value, string? format, IFormatProvid { return Int64ToHexStr((long)value, GetHexBase(fmt), digits); } + else if (fmtUpper == 'B') + { + return UInt64ToBinaryStr(value, digits); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1309,6 +1344,10 @@ static unsafe bool TryFormatUInt64Slow(ulong value, ReadOnlySpan format, I { return TryInt64ToHexStr((long)value, GetHexBase(fmt), digits, destination, out charsWritten); } + else if (fmtUpper == 'B') + { + return TryUInt64ToBinaryStr(value, digits, destination, out charsWritten); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1366,6 +1405,10 @@ static unsafe string FormatInt128Slow(Int128 value, string? format, IFormatProvi { return Int128ToHexStr(value, GetHexBase(fmt), digits); } + else if (fmtUpper == 'B') + { + return UInt128ToBinaryStr(value, digits); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1423,6 +1466,10 @@ static unsafe bool TryFormatInt128Slow(Int128 value, ReadOnlySpan format, { return TryInt128ToHexStr(value, GetHexBase(fmt), digits, destination, out charsWritten); } + else if (fmtUpper == 'B') + { + return TryUInt128ToBinaryStr(value, digits, destination, out charsWritten); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1476,6 +1523,10 @@ static unsafe string FormatUInt128Slow(UInt128 value, string? format, IFormatPro { return Int128ToHexStr((Int128)value, GetHexBase(fmt), digits); } + else if (fmtUpper == 'B') + { + return UInt128ToBinaryStr((Int128)value, digits); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1529,6 +1580,10 @@ static unsafe bool TryFormatUInt128Slow(UInt128 value, ReadOnlySpan format { return TryInt128ToHexStr((Int128)value, GetHexBase(fmt), digits, destination, out charsWritten); } + else if (fmtUpper == 'B') + { + return TryUInt128ToBinaryStr((Int128)value, digits, destination, out charsWritten); + } else { NumberFormatInfo info = NumberFormatInfo.GetInstance(provider); @@ -1708,6 +1763,61 @@ private static unsafe bool TryInt32ToHexStr(int value, char hexBase, int return buffer; } + private static unsafe string UInt32ToBinaryStr(uint value, int digits) + { + if (digits < 1) + { + digits = 1; + } + + int bufferLength = Math.Max(digits, 32 - (int)uint.LeadingZeroCount(value)); + string result = string.FastAllocateString(bufferLength); + fixed (char* buffer = result) + { + char* p = UInt32ToBinaryChars(buffer + bufferLength, value, digits); + Debug.Assert(p == buffer); + } + return result; + } + + private static unsafe bool TryUInt32ToBinaryStr(uint value, int digits, Span destination, out int charsWritten) where TChar : unmanaged, IUtfChar + { + Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte)); + + if (digits < 1) + { + digits = 1; + } + + int bufferLength = Math.Max(digits, 32 - (int)uint.LeadingZeroCount(value)); + if (bufferLength > destination.Length) + { + charsWritten = 0; + return false; + } + + charsWritten = bufferLength; + fixed (TChar* buffer = &MemoryMarshal.GetReference(destination)) + { + TChar* p = UInt32ToBinaryChars(buffer + bufferLength, value, digits); + Debug.Assert(p == buffer); + } + return true; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static unsafe TChar* UInt32ToBinaryChars(TChar* buffer, uint value, int digits) where TChar : unmanaged, IUtfChar + { + Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte)); + + while (--digits >= 0 || value != 0) + { + *(--buffer) = TChar.CastFrom('0' + (byte)(value & 0x1)); + value >>= 1; + } + return buffer; + } + [MethodImpl(MethodImplOptions.AggressiveInlining)] private static unsafe void UInt32ToNumber(uint value, ref NumberBuffer number) { @@ -2102,6 +2212,77 @@ private static unsafe bool TryInt64ToHexStr(long value, char hexBase, int #endif } + private static unsafe string UInt64ToBinaryStr(ulong value, int digits) + { + if (digits < 1) + { + digits = 1; + } + + int bufferLength = Math.Max(digits, 64 - (int)ulong.LeadingZeroCount(value)); + string result = string.FastAllocateString(bufferLength); + fixed (char* buffer = result) + { + char* p = UInt64ToBinaryChars(buffer + bufferLength, value, digits); + Debug.Assert(p == buffer); + } + return result; + } + + private static unsafe bool TryUInt64ToBinaryStr(ulong value, int digits, Span destination, out int charsWritten) where TChar : unmanaged, IUtfChar + { + Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte)); + + if (digits < 1) + { + digits = 1; + } + + int bufferLength = Math.Max(digits, 64 - (int)ulong.LeadingZeroCount(value)); + if (bufferLength > destination.Length) + { + charsWritten = 0; + return false; + } + + charsWritten = bufferLength; + fixed (TChar* buffer = &MemoryMarshal.GetReference(destination)) + { + TChar* p = UInt64ToBinaryChars(buffer + bufferLength, value, digits); + Debug.Assert(p == buffer); + } + return true; + } + +#if TARGET_64BIT + [MethodImpl(MethodImplOptions.AggressiveInlining)] +#endif + private static unsafe TChar* UInt64ToBinaryChars(TChar* buffer, ulong value, int digits) where TChar : unmanaged, IUtfChar + { + Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte)); +#if TARGET_32BIT + uint lower = (uint)value; + uint upper = (uint)(value >> 32); + + if (upper != 0) + { + buffer = UInt32ToBinaryChars(buffer, lower, 32); + return UInt32ToBinaryChars(buffer, upper, digits - 32); + } + else + { + return UInt32ToBinaryChars(buffer, lower, Math.Max(digits, 1)); + } +#else + while (--digits >= 0 || value != 0) + { + *(--buffer) = TChar.CastFrom('0' + (byte)(value & 0x1)); + value >>= 1; + } + return buffer; +#endif + } + [MethodImpl(MethodImplOptions.AggressiveInlining)] private static unsafe void UInt64ToNumber(ulong value, ref NumberBuffer number) { @@ -2452,6 +2633,69 @@ private static unsafe bool TryInt128ToHexStr(Int128 value, char hexBase, } } + private static unsafe string UInt128ToBinaryStr(Int128 value, int digits) + { + if (digits < 1) + { + digits = 1; + } + + UInt128 uValue = (UInt128)value; + + int bufferLength = Math.Max(digits, 128 - (int)UInt128.LeadingZeroCount((UInt128)value)); + string result = string.FastAllocateString(bufferLength); + fixed (char* buffer = result) + { + char* p = UInt128ToBinaryChars(buffer + bufferLength, uValue, digits); + Debug.Assert(p == buffer); + } + return result; + } + + private static unsafe bool TryUInt128ToBinaryStr(Int128 value, int digits, Span destination, out int charsWritten) where TChar : unmanaged, IUtfChar + { + Debug.Assert(typeof(TChar) == typeof(char) || typeof(TChar) == typeof(byte)); + + if (digits < 1) + { + digits = 1; + } + + UInt128 uValue = (UInt128)value; + + int bufferLength = Math.Max(digits, 128 - (int)UInt128.LeadingZeroCount((UInt128)value)); + if (bufferLength > destination.Length) + { + charsWritten = 0; + return false; + } + + charsWritten = bufferLength; + fixed (TChar* buffer = &MemoryMarshal.GetReference(destination)) + { + TChar* p = UInt128ToBinaryChars(buffer + bufferLength, uValue, digits); + Debug.Assert(p == buffer); + } + return true; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static unsafe TChar* UInt128ToBinaryChars(TChar* buffer, UInt128 value, int digits) where TChar : unmanaged, IUtfChar + { + ulong lower = value.Lower; + ulong upper = value.Upper; + + if (upper != 0) + { + buffer = UInt64ToBinaryChars(buffer, lower, 64); + return UInt64ToBinaryChars(buffer, upper, digits - 64); + } + else + { + return UInt64ToBinaryChars(buffer, lower, Math.Max(digits, 1)); + } + } + private static unsafe void UInt128ToNumber(UInt128 value, ref NumberBuffer number) { number.DigitsCount = UInt128Precision; diff --git a/src/libraries/System.Private.CoreLib/src/System/ParseNumbers.cs b/src/libraries/System.Private.CoreLib/src/System/ParseNumbers.cs index 70fac44ccfe0c..76c4f52cb8719 100644 --- a/src/libraries/System.Private.CoreLib/src/System/ParseNumbers.cs +++ b/src/libraries/System.Private.CoreLib/src/System/ParseNumbers.cs @@ -9,23 +9,10 @@ namespace System /// Methods for parsing numbers and strings. internal static class ParseNumbers { - internal const int LeftAlign = 0x0001; - internal const int RightAlign = 0x0004; - internal const int PrefixSpace = 0x0008; - internal const int PrintSign = 0x0010; - internal const int PrintBase = 0x0020; - internal const int PrintAsI1 = 0x0040; - internal const int PrintAsI2 = 0x0080; - internal const int PrintAsI4 = 0x0100; internal const int TreatAsUnsigned = 0x0200; internal const int TreatAsI1 = 0x0400; internal const int TreatAsI2 = 0x0800; internal const int IsTight = 0x1000; - internal const int NoSpace = 0x2000; - internal const int PrintRadixBase = 0x4000; - - private const int MinRadix = 2; - private const int MaxRadix = 36; public static unsafe long StringToLong(ReadOnlySpan s, int radix, int flags) { @@ -51,7 +38,7 @@ public static long StringToLong(ReadOnlySpan s, int radix, int flags, ref throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_IndexMustBeLess); // Get rid of the whitespace and then check that we've still got some digits to parse. - if (((flags & IsTight) == 0) && ((flags & NoSpace) == 0)) + if ((flags & IsTight) == 0) { EatWhiteSpace(s, ref i); if (i == length) @@ -139,7 +126,7 @@ public static int StringToInt(ReadOnlySpan s, int radix, int flags, ref in throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_IndexMustBeLess); // Get rid of the whitespace and then check that we've still got some digits to parse. - if (((flags & IsTight) == 0) && ((flags & NoSpace) == 0)) + if ((flags & IsTight) == 0) { EatWhiteSpace(s, ref i); if (i == length) @@ -215,294 +202,6 @@ public static int StringToInt(ReadOnlySpan s, int radix, int flags, ref in return result; } - public static string IntToString(int n, int radix, int width, char paddingChar, int flags) - { - Span buffer = stackalloc char[66]; // Longest possible string length for an integer in binary notation with prefix - - if (radix < MinRadix || radix > MaxRadix) - throw new ArgumentException(SR.Arg_InvalidBase, nameof(radix)); - - // If the number is negative, make it positive and remember the sign. - // If the number is MIN_VALUE, this will still be negative, so we'll have to - // special case this later. - bool isNegative = false; - uint l; - if (n < 0) - { - isNegative = true; - - // For base 10, write out -num, but other bases write out the - // 2's complement bit pattern - l = (10 == radix) ? (uint)-n : (uint)n; - } - else - { - l = (uint)n; - } - - // The conversion to a uint will sign extend the number. In order to ensure - // that we only get as many bits as we expect, we chop the number. - if ((flags & PrintAsI1) != 0) - { - l &= 0xFF; - } - else if ((flags & PrintAsI2) != 0) - { - l &= 0xFFFF; - } - - // Special case the 0. - int index; - if (0 == l) - { - buffer[0] = '0'; - index = 1; - } - else - { - index = 0; - for (int i = 0; i < buffer.Length; i++) // for (...;i buffer = stackalloc char[67]; // Longest possible string length for an integer in binary notation with prefix - - if (radix < MinRadix || radix > MaxRadix) - throw new ArgumentException(SR.Arg_InvalidBase, nameof(radix)); - - // If the number is negative, make it positive and remember the sign. - ulong ul; - bool isNegative = false; - if (n < 0) - { - isNegative = true; - - // For base 10, write out -num, but other bases write out the - // 2's complement bit pattern - ul = (10 == radix) ? (ulong)(-n) : (ulong)n; - } - else - { - ul = (ulong)n; - } - - if ((flags & PrintAsI1) != 0) - { - ul &= 0xFF; - } - else if ((flags & PrintAsI2) != 0) - { - ul &= 0xFFFF; - } - else if ((flags & PrintAsI4) != 0) - { - ul &= 0xFFFFFFFF; - } - - // Special case the 0. - int index; - if (0 == ul) - { - buffer[0] = '0'; - index = 1; - } - else - { - index = 0; - for (int i = 0; i < buffer.Length; i++) // for loop instead of do{...}while(l!=0) to help JIT eliminate span bounds checks - { - ulong div = ul / (ulong)radix; // TODO https://github.com/dotnet/runtime/issues/5213 - int charVal = (int)(ul - (div * (ulong)radix)); - ul = div; - - buffer[i] = (charVal < 10) ? - (char)(charVal + '0') : - (char)(charVal + 'a' - 10); - - if (ul == 0) - { - index = i + 1; - break; - } - } - Debug.Assert(ul == 0, $"Expected {ul} == 0"); - } - - // If they want the base, append that to the string (in reverse order) - if (radix != 10 && ((flags & PrintBase) != 0)) - { - if (16 == radix) - { - buffer[index++] = 'x'; - buffer[index++] = '0'; - } - else if (8 == radix) - { - buffer[index++] = '0'; - } - else if ((flags & PrintRadixBase) != 0) - { - buffer[index++] = '#'; - buffer[index++] = (char)((radix % 10) + '0'); - buffer[index++] = (char)((radix / 10) + '0'); - } - } - - if (10 == radix) - { - // If it was negative, append the sign. - if (isNegative) - { - buffer[index++] = '-'; - } - - // else if they requested, add the '+'; - else if ((flags & PrintSign) != 0) - { - buffer[index++] = '+'; - } - - // If they requested a leading space, put it on. - else if ((flags & PrefixSpace) != 0) - { - buffer[index++] = ' '; - } - } - - // Figure out the size of and allocate the resulting string - string result = string.FastAllocateString(Math.Max(width, index)); - unsafe - { - // Put the characters into the string in reverse order. - // Fill the remaining space, if there is any, with the correct padding character. - fixed (char* resultPtr = result) - { - char* p = resultPtr; - int padding = result.Length - index; - - if ((flags & LeftAlign) != 0) - { - for (int i = 0; i < padding; i++) - { - *p++ = paddingChar; - } - - for (int i = 0; i < index; i++) - { - *p++ = buffer[index - i - 1]; - } - } - else - { - for (int i = 0; i < index; i++) - { - *p++ = buffer[index - i - 1]; - } - - for (int i = 0; i < padding; i++) - { - *p++ = paddingChar; - } - } - - Debug.Assert((p - resultPtr) == result.Length, $"Expected {p - resultPtr} == {result.Length}"); - } - } - return result; - } - private static void EatWhiteSpace(ReadOnlySpan s, ref int i) { int localIndex = i; diff --git a/src/libraries/System.Runtime/tests/System/ByteTests.cs b/src/libraries/System.Runtime/tests/System/ByteTests.cs index 94c41f34aa95d..6fdd9bc01646a 100644 --- a/src/libraries/System.Runtime/tests/System/ByteTests.cs +++ b/src/libraries/System.Runtime/tests/System/ByteTests.cs @@ -99,11 +99,15 @@ public static IEnumerable ToString_TestData() yield return new object[] { (byte)123, "D", emptyFormat, "123" }; yield return new object[] { (byte)123, "D99", emptyFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123" }; + yield return new object[] { (byte)0, "x", emptyFormat, "0" }; yield return new object[] { (byte)0x24, "x", emptyFormat, "24" }; - yield return new object[] { (byte)24, "N", emptyFormat, string.Format("{0:N}", 24.00) }; + yield return new object[] { (byte)0, "b", emptyFormat, "0" }; + yield return new object[] { (byte)0x24, "b", emptyFormat, "100100" }; + yield return new object[] { (byte)24, "N", emptyFormat, string.Format("{0:N}", 24.00) }; } + NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo; yield return new object[] { (byte)32, "C100", invariantFormat, "\u00A432.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (byte)32, "P100", invariantFormat, "3,200.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %" }; @@ -112,6 +116,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (byte)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (byte)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (byte)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (byte)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/Int128Tests.cs b/src/libraries/System.Runtime/tests/System/Int128Tests.cs index 1161a6d763a79..c8e22a6be7764 100644 --- a/src/libraries/System.Runtime/tests/System/Int128Tests.cs +++ b/src/libraries/System.Runtime/tests/System/Int128Tests.cs @@ -130,8 +130,14 @@ public static IEnumerable ToString_TestData() yield return new object[] { (Int128)4567, "D99\09", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; yield return new object[] { (Int128)(-4567), "D99", defaultFormat, "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; + yield return new object[] { (Int128)0, "x", defaultFormat, "0" }; yield return new object[] { (Int128)0x2468, "x", defaultFormat, "2468" }; yield return new object[] { (Int128)(-0x2468), "x", defaultFormat, "ffffffffffffffffffffffffffffdb98" }; + + yield return new object[] { (Int128)0, "b", defaultFormat, "0" }; + yield return new object[] { (Int128)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (Int128)(-0x2468), "b", defaultFormat, "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111101101110011000" }; + yield return new object[] { (Int128)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } @@ -143,6 +149,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (Int128)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (Int128)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (Int128)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (Int128)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/Int16Tests.cs b/src/libraries/System.Runtime/tests/System/Int16Tests.cs index 60ffdcac3158a..5961735ee0eee 100644 --- a/src/libraries/System.Runtime/tests/System/Int16Tests.cs +++ b/src/libraries/System.Runtime/tests/System/Int16Tests.cs @@ -115,11 +115,15 @@ public static IEnumerable ToString_TestData() yield return new object[] { (short)4567, "D99\09", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; yield return new object[] { (short)-4567, "D99", defaultFormat, "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; + yield return new object[] { (short)0, "x", defaultFormat, "0" }; yield return new object[] { (short)0x2468, "x", defaultFormat, "2468" }; yield return new object[] { (short)-0x2468, "x", defaultFormat, "db98" }; - yield return new object[] { (short)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; + yield return new object[] { (short)0, "b", defaultFormat, "0" }; + yield return new object[] { (short)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (short)-0x2468, "b", defaultFormat, "1101101110011000" }; + yield return new object[] { (short)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo; @@ -130,6 +134,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (short)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (short)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (short)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (short)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/Int32Tests.cs b/src/libraries/System.Runtime/tests/System/Int32Tests.cs index e619fff5ea5dc..4230c9a4194ae 100644 --- a/src/libraries/System.Runtime/tests/System/Int32Tests.cs +++ b/src/libraries/System.Runtime/tests/System/Int32Tests.cs @@ -115,8 +115,14 @@ public static IEnumerable ToString_TestData() yield return new object[] { 4567, "D99\09", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; yield return new object[] { -4567, "D99\09", defaultFormat, "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; + yield return new object[] { 0, "x", defaultFormat, "0" }; yield return new object[] { 0x2468, "x", defaultFormat, "2468" }; yield return new object[] { -0x2468, "x", defaultFormat, "ffffdb98" }; + + yield return new object[] { 0, "b", defaultFormat, "0" }; + yield return new object[] { 0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { -0x2468, "b", defaultFormat, "11111111111111111101101110011000" }; + yield return new object[] { 2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } @@ -129,6 +135,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { 32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { 32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { 32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { 32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/Int64Tests.cs b/src/libraries/System.Runtime/tests/System/Int64Tests.cs index 052ae58bdd818..da476b279cde6 100644 --- a/src/libraries/System.Runtime/tests/System/Int64Tests.cs +++ b/src/libraries/System.Runtime/tests/System/Int64Tests.cs @@ -116,11 +116,15 @@ public static IEnumerable ToString_TestData() yield return new object[] { (long)4567, "D99\09", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; yield return new object[] { (long)-4567, "D99", defaultFormat, "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; + yield return new object[] { (long)0, "x", defaultFormat, "0" }; yield return new object[] { (long)0x2468, "x", defaultFormat, "2468" }; yield return new object[] { (long)-0x2468, "x", defaultFormat, "ffffffffffffdb98" }; - yield return new object[] { (long)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; + yield return new object[] { (long)0, "b", defaultFormat, "0" }; + yield return new object[] { (long)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (long)-0x2468, "b", defaultFormat, "1111111111111111111111111111111111111111111111111101101110011000" }; + yield return new object[] { (long)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo; @@ -131,6 +135,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (long)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (long)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (long)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (long)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/IntPtrTests.cs b/src/libraries/System.Runtime/tests/System/IntPtrTests.cs index 24cc1d3d85856..147848f5e1179 100644 --- a/src/libraries/System.Runtime/tests/System/IntPtrTests.cs +++ b/src/libraries/System.Runtime/tests/System/IntPtrTests.cs @@ -287,8 +287,14 @@ public static IEnumerable ToString_TestData() yield return new object[] { (nint)4567, "D99\09", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; yield return new object[] { (nint)(-4567), "D99\09", defaultFormat, "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004567" }; + yield return new object[] { (nint)0, "x", defaultFormat, "0" }; yield return new object[] { (nint)0x2468, "x", defaultFormat, "2468" }; yield return new object[] { (nint)(-0x2468), "x", defaultFormat, Is64Bit ? "ffffffffffffdb98" : "ffffdb98" }; + + yield return new object[] { (nint)0, "b", defaultFormat, "0" }; + yield return new object[] { (nint)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (nint)(-0x2468), "b", defaultFormat, Is64Bit ? "1111111111111111111111111111111111111111111111111101101110011000" : "11111111111111111101101110011000" }; + yield return new object[] { (nint)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } diff --git a/src/libraries/System.Runtime/tests/System/SByteTests.cs b/src/libraries/System.Runtime/tests/System/SByteTests.cs index 7a2b9b946f4b7..2768a5d1655c9 100644 --- a/src/libraries/System.Runtime/tests/System/SByteTests.cs +++ b/src/libraries/System.Runtime/tests/System/SByteTests.cs @@ -112,11 +112,15 @@ public static IEnumerable ToString_TestData() yield return new object[] { (sbyte)123, "D99\09", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123" }; yield return new object[] { (sbyte)-123, "D99", defaultFormat, "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123" }; + yield return new object[] { (sbyte)0, "x", defaultFormat, "0" }; yield return new object[] { (sbyte)0x24, "x", defaultFormat, "24" }; yield return new object[] { (sbyte)-0x24, "x", defaultFormat, "dc" }; - yield return new object[] { (sbyte)24, "N", defaultFormat, string.Format("{0:N}", 24.00) }; + yield return new object[] { (sbyte)0, "b", defaultFormat, "0" }; + yield return new object[] { (sbyte)0x24, "b", defaultFormat, "100100" }; + yield return new object[] { (sbyte)-0x24, "b", defaultFormat, "11011100" }; + yield return new object[] { (sbyte)24, "N", defaultFormat, string.Format("{0:N}", 24.00) }; } NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo; @@ -127,6 +131,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (sbyte)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (sbyte)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (sbyte)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (sbyte)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/UInt128Tests.cs b/src/libraries/System.Runtime/tests/System/UInt128Tests.cs index ba67e15edb155..9482b480fb6f5 100644 --- a/src/libraries/System.Runtime/tests/System/UInt128Tests.cs +++ b/src/libraries/System.Runtime/tests/System/UInt128Tests.cs @@ -115,7 +115,12 @@ public static IEnumerable ToString_TestData() yield return new object[] { (UInt128)4567, "D", defaultFormat, "4567" }; yield return new object[] { (UInt128)4567, "D18", defaultFormat, "000000000000004567" }; + yield return new object[] { (UInt128)0, "x", defaultFormat, "0" }; yield return new object[] { (UInt128)0x2468, "x", defaultFormat, "2468" }; + + yield return new object[] { (UInt128)0, "b", defaultFormat, "0" }; + yield return new object[] { (UInt128)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (UInt128)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; @@ -129,6 +134,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (UInt128)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (UInt128)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (UInt128)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (UInt128)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/UInt16Tests.cs b/src/libraries/System.Runtime/tests/System/UInt16Tests.cs index d43738f0e64a5..b0ab9d1dac783 100644 --- a/src/libraries/System.Runtime/tests/System/UInt16Tests.cs +++ b/src/libraries/System.Runtime/tests/System/UInt16Tests.cs @@ -99,7 +99,12 @@ public static IEnumerable ToString_TestData() yield return new object[] { (ushort)123, "D", defaultFormat, "123" }; yield return new object[] { (ushort)123, "D99", defaultFormat, "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123" }; + yield return new object[] { (ushort)0, "x", defaultFormat, "0" }; yield return new object[] { (ushort)0x2468, "x", defaultFormat, "2468" }; + + yield return new object[] { (ushort)0, "b", defaultFormat, "0" }; + yield return new object[] { (ushort)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (ushort)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } @@ -111,6 +116,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (ushort)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (ushort)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (ushort)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (ushort)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/UInt32Tests.cs b/src/libraries/System.Runtime/tests/System/UInt32Tests.cs index d85edb2f401b3..694bb7f432639 100644 --- a/src/libraries/System.Runtime/tests/System/UInt32Tests.cs +++ b/src/libraries/System.Runtime/tests/System/UInt32Tests.cs @@ -100,9 +100,13 @@ public static IEnumerable ToString_TestData() yield return new object[] { (uint)4567, "D", defaultFormat, "4567" }; yield return new object[] { (uint)4567, "D18", defaultFormat, "000000000000004567" }; + yield return new object[] { (uint)0, "x", defaultFormat, "0" }; yield return new object[] { (uint)0x2468, "x", defaultFormat, "2468" }; - yield return new object[] { (uint)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; + yield return new object[] { (uint)0, "b", defaultFormat, "0" }; + yield return new object[] { (uint)0x2468, "b", defaultFormat, "10010001101000" }; + + yield return new object[] { (uint)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo; @@ -113,6 +117,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (uint)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (uint)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (uint)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (uint)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/UInt64Tests.cs b/src/libraries/System.Runtime/tests/System/UInt64Tests.cs index c8fae97320698..fb96368e711ce 100644 --- a/src/libraries/System.Runtime/tests/System/UInt64Tests.cs +++ b/src/libraries/System.Runtime/tests/System/UInt64Tests.cs @@ -99,10 +99,13 @@ public static IEnumerable ToString_TestData() yield return new object[] { (ulong)4567, "D", defaultFormat, "4567" }; yield return new object[] { (ulong)4567, "D18", defaultFormat, "000000000000004567" }; + yield return new object[] { (ulong)0, "x", defaultFormat, "0" }; yield return new object[] { (ulong)0x2468, "x", defaultFormat, "2468" }; - yield return new object[] { (ulong)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; + yield return new object[] { (ulong)0, "b", defaultFormat, "0" }; + yield return new object[] { (ulong)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (ulong)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; } NumberFormatInfo invariantFormat = NumberFormatInfo.InvariantInfo; @@ -113,6 +116,7 @@ public static IEnumerable ToString_TestData() yield return new object[] { (ulong)32, "F100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (ulong)32, "N100", invariantFormat, "32.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }; yield return new object[] { (ulong)32, "X100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020" }; + yield return new object[] { (ulong)32, "B100", invariantFormat, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000" }; var customFormat = new NumberFormatInfo() { diff --git a/src/libraries/System.Runtime/tests/System/UIntPtrTests.cs b/src/libraries/System.Runtime/tests/System/UIntPtrTests.cs index ff8a857b9cda8..4f4626f07fd49 100644 --- a/src/libraries/System.Runtime/tests/System/UIntPtrTests.cs +++ b/src/libraries/System.Runtime/tests/System/UIntPtrTests.cs @@ -268,7 +268,12 @@ public static IEnumerable ToString_TestData() yield return new object[] { (nuint)4567, "D", defaultFormat, "4567" }; yield return new object[] { (nuint)4567, "D18", defaultFormat, "000000000000004567" }; + yield return new object[] { (nuint)0, "x", defaultFormat, "0" }; yield return new object[] { (nuint)0x2468, "x", defaultFormat, "2468" }; + + yield return new object[] { (nuint)0, "b", defaultFormat, "0" }; + yield return new object[] { (nuint)0x2468, "b", defaultFormat, "10010001101000" }; + yield return new object[] { (nuint)2468, "N", defaultFormat, string.Format("{0:N}", 2468.00) }; }