netcore/System.Private.CoreLib/shared/System/Buffers/Text/Utf8Parser/Utf8Parser.Number.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Diagnostics;
   6
   7 namespace System.Buffers.Text
   8 {
   9     public static partial class Utf8Parser
  10     {
  11         [Flags]
  12         private enum ParseNumberOptions
  13         {
  14             AllowExponent = 0x00000001,
  15         }
  16
  17         private static bool TryParseNumber(ReadOnlySpan<byte> source, ref Number.NumberBuffer number, out int bytesConsumed, ParseNumberOptions options, out bool textUsedExponentNotation)
  18         {
  19             Debug.Assert(number.DigitsCount == 0);
  20             Debug.Assert(number.Scale == 0);
  21             Debug.Assert(!number.IsNegative);
  22             Debug.Assert(!number.HasNonZeroTail);
  23
  24             number.CheckConsistency();
  25             textUsedExponentNotation = false;
  26
  27             if (source.Length == 0)
  28             {
  29                 bytesConsumed = 0;
  30                 return false;
  31             }
  32
  33             Span<byte> digits = number.Digits;
  34
  35             int srcIndex = 0;
  36             int dstIndex = 0;
  37
  38             // Consume the leading sign if any.
  39             byte c = source[srcIndex];
  40             switch (c)
  41             {
  42                 case Utf8Constants.Minus:
  43                     number.IsNegative = true;
  44                     goto case Utf8Constants.Plus;
  45
  46                 case Utf8Constants.Plus:
  47                     srcIndex++;
  48                     if (srcIndex == source.Length)
  49                     {
  50                         bytesConsumed = 0;
  51                         return false;
  52                     }
  53                     c = source[srcIndex];
  54                     break;
  55
  56                 default:
  57                     break;
  58             }
  59
  60             int startIndexDigitsBeforeDecimal = srcIndex;
  61             int digitCount = 0;
  62             int maxDigitCount = digits.Length - 1;
  63
  64             // Throw away any leading zeroes
  65             while (srcIndex != source.Length)
  66             {
  67                 c = source[srcIndex];
  68                 if (c != '0')
  69                     break;
  70                 srcIndex++;
  71             }
  72
  73             if (srcIndex == source.Length)
  74             {
  75                 bytesConsumed = srcIndex;
  76                 number.CheckConsistency();
  77                 return true;
  78             }
  79
  80             int startIndexNonLeadingDigitsBeforeDecimal = srcIndex;
  81
  82             int hasNonZeroTail = 0;
  83             while (srcIndex != source.Length)
  84             {
  85                 c = source[srcIndex];
  86                 int value = (byte)(c - (byte)('0'));
  87
  88                 if (value > 9)
  89                 {
  90                     break;
  91                 }
  92
  93                 srcIndex++;
  94                 digitCount++;
  95
  96                 if (digitCount >= maxDigitCount)
  97                 {
  98                     // For decimal and binary floating-point numbers, we only
  99                     // need to store digits up to maxDigCount. However, we still
 100                     // need to keep track of whether any additional digits past
 101                     // maxDigCount were non-zero, as that can impact rounding
 102                     // for an input that falls evenly between two representable
 103                     // results.
 104
 105                     hasNonZeroTail |= value;
 106                 }
 107             }
 108             number.HasNonZeroTail = (hasNonZeroTail != 0);
 109
 110             int numDigitsBeforeDecimal = srcIndex - startIndexDigitsBeforeDecimal;
 111             int numNonLeadingDigitsBeforeDecimal = srcIndex - startIndexNonLeadingDigitsBeforeDecimal;
 112
 113             Debug.Assert(dstIndex == 0);
 114             int numNonLeadingDigitsBeforeDecimalToCopy = Math.Min(numNonLeadingDigitsBeforeDecimal, maxDigitCount);
 115             source.Slice(startIndexNonLeadingDigitsBeforeDecimal, numNonLeadingDigitsBeforeDecimalToCopy).CopyTo(digits);
 116             dstIndex = numNonLeadingDigitsBeforeDecimalToCopy;
 117             number.Scale = numNonLeadingDigitsBeforeDecimal;
 118
 119             if (srcIndex == source.Length)
 120             {
 121                 digits[dstIndex] = 0;
 122                 number.DigitsCount = dstIndex;
 123                 bytesConsumed = srcIndex;
 124                 number.CheckConsistency();
 125                 return true;
 126             }
 127
 128             int numDigitsAfterDecimal = 0;
 129             if (c == Utf8Constants.Period)
 130             {
 131                 //
 132                 // Parse the digits after the decimal point.
 133                 //
 134
 135                 srcIndex++;
 136                 int startIndexDigitsAfterDecimal = srcIndex;
 137
 138                 while (srcIndex != source.Length)
 139                 {
 140                     c = source[srcIndex];
 141                     int value = (byte)(c - (byte)('0'));
 142
 143                     if (value > 9)
 144                     {
 145                         break;
 146                     }
 147
 148                     srcIndex++;
 149                     digitCount++;
 150
 151                     if (digitCount >= maxDigitCount)
 152                     {
 153                         // For decimal and binary floating-point numbers, we only
 154                         // need to store digits up to maxDigCount. However, we still
 155                         // need to keep track of whether any additional digits past
 156                         // maxDigCount were non-zero, as that can impact rounding
 157                         // for an input that falls evenly between two representable
 158                         // results.
 159
 160                         hasNonZeroTail |= value;
 161                     }
 162                 }
 163                 number.HasNonZeroTail = (hasNonZeroTail != 0);
 164
 165                 numDigitsAfterDecimal = srcIndex - startIndexDigitsAfterDecimal;
 166
 167                 int startIndexOfDigitsAfterDecimalToCopy = startIndexDigitsAfterDecimal;
 168                 if (dstIndex == 0)
 169                 {
 170                     // Not copied any digits to the Number struct yet. This means we must continue discarding leading zeroes even though they appeared after the decimal point.
 171                     while (startIndexOfDigitsAfterDecimalToCopy < srcIndex && source[startIndexOfDigitsAfterDecimalToCopy] == '0')
 172                     {
 173                         number.Scale--;
 174                         startIndexOfDigitsAfterDecimalToCopy++;
 175                     }
 176                 }
 177
 178                 int numDigitsAfterDecimalToCopy = Math.Min(srcIndex - startIndexOfDigitsAfterDecimalToCopy, maxDigitCount - dstIndex);
 179                 source.Slice(startIndexOfDigitsAfterDecimalToCopy, numDigitsAfterDecimalToCopy).CopyTo(digits.Slice(dstIndex));
 180                 dstIndex += numDigitsAfterDecimalToCopy;
 181                 // We "should" really NUL terminate, but there are multiple places we'd have to do this and it is a precondition that the caller pass in a fully zero=initialized Number.
 182
 183                 if (srcIndex == source.Length)
 184                 {
 185                     if (numDigitsBeforeDecimal == 0 && numDigitsAfterDecimal == 0)
 186                     {
 187                         // For compatibility. You can say "5." and ".5" but you can't say "."
 188                         bytesConsumed = 0;
 189                         return false;
 190                     }
 191
 192                     digits[dstIndex] = 0;
 193                     number.DigitsCount = dstIndex;
 194                     bytesConsumed = srcIndex;
 195                     number.CheckConsistency();
 196                     return true;
 197                 }
 198             }
 199
 200             if (numDigitsBeforeDecimal == 0 && numDigitsAfterDecimal == 0)
 201             {
 202                 bytesConsumed = 0;
 203                 return false;
 204             }
 205
 206             if ((c & ~0x20u) != 'E')
 207             {
 208                 digits[dstIndex] = 0;
 209                 number.DigitsCount = dstIndex;
 210                 bytesConsumed = srcIndex;
 211                 number.CheckConsistency();
 212                 return true;
 213             }
 214
 215             //
 216             // Parse the exponent after the "E"
 217             //
 218             textUsedExponentNotation = true;
 219             srcIndex++;
 220
 221             if ((options & ParseNumberOptions.AllowExponent) == 0)
 222             {
 223                 bytesConsumed = 0;
 224                 return false;
 225             }
 226
 227             if (srcIndex == source.Length)
 228             {
 229                 bytesConsumed = 0;
 230                 return false;
 231             }
 232
 233             bool exponentIsNegative = false;
 234             c = source[srcIndex];
 235             switch (c)
 236             {
 237                 case Utf8Constants.Minus:
 238                     exponentIsNegative = true;
 239                     goto case Utf8Constants.Plus;
 240
 241                 case Utf8Constants.Plus:
 242                     srcIndex++;
 243                     if (srcIndex == source.Length)
 244                     {
 245                         bytesConsumed = 0;
 246                         return false;
 247                     }
 248                     c = source[srcIndex];
 249                     break;
 250
 251                 default:
 252                     break;
 253             }
 254
 255             // If the next character isn't a digit, an exponent wasn't specified
 256             if ((byte)(c - (byte)('0')) > 9)
 257             {
 258                 bytesConsumed = 0;
 259                 return false;
 260             }
 261
 262             if (!TryParseUInt32D(source.Slice(srcIndex), out uint absoluteExponent, out int bytesConsumedByExponent))
 263             {
 264                 // Since we found at least one digit, we know that any failure to parse means we had an
 265                 // exponent that was larger than uint.MaxValue, and we can just eat characters until the end
 266                 absoluteExponent = uint.MaxValue;
 267
 268                 // This also means that we know there was at least 10 characters and we can "eat" those, and
 269                 // continue eating digits from there
 270                 srcIndex += 10;
 271
 272                 while (srcIndex != source.Length)
 273                 {
 274                     c = source[srcIndex];
 275                     int value = (byte)(c - (byte)('0'));
 276
 277                     if (value > 9)
 278                     {
 279                         break;
 280                     }
 281
 282                     srcIndex++;
 283                 }
 284             }
 285
 286             srcIndex += bytesConsumedByExponent;
 287
 288             if (exponentIsNegative)
 289             {
 290                 if (number.Scale < int.MinValue + (long)absoluteExponent)
 291                 {
 292                     // A scale underflow means all non-zero digits are all so far to the right of the decimal point, no
 293                     // number format we have will be able to see them. Just pin the scale at the absolute minimum
 294                     // and let the converter produce a 0 with the max precision available for that type.
 295                     number.Scale = int.MinValue;
 296                 }
 297                 else
 298                 {
 299                     number.Scale -= (int)absoluteExponent;
 300                 }
 301             }
 302             else
 303             {
 304                 if (number.Scale > int.MaxValue - (long)absoluteExponent)
 305                 {
 306                     // A scale overflow means all non-zero digits are all so far to the right of the decimal point, no
 307                     // number format we have will be able to see them. Just pin the scale at the absolute maximum
 308                     // and let the converter produce a 0 with the max precision available for that type.
 309                     number.Scale = int.MaxValue;
 310                 }
 311                 else
 312                 {
 313                     number.Scale += (int)absoluteExponent;
 314                 }
 315             }
 316
 317             digits[dstIndex] = 0;
 318             number.DigitsCount = dstIndex;
 319             bytesConsumed = srcIndex;
 320             number.CheckConsistency();
 321             return true;
 322         }
 323     }
 324 }