Summary

Class:	System.Buffers.Text.Utf8Parser
Assembly:	System.Memory
File(s):	C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Boolean.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.Default.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.G.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.Helpers.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.O.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.R.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Decimal.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Float.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Guid.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.D.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.N.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.D.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.N.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.X.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.BigG.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.C.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.LittleG.cs C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpanSplitter.cs
Covered lines:	2871
Uncovered lines:	4
Coverable lines:	2875
Total lines:	4826
Line coverage:	99.8%
Branch coverage:	96.9%

Metrics

Method	Cyclomatic complexity	NPath complexity	Sequence coverage	Branch coverage
TryParse(...)	26	32	100	100
TryParse(...)	12	1024	100	95.24
TryParse(...)	7	32	100	100
TryParseDateTimeOffsetDefault(...)	13	512	100	100
TryParseDateTimeG(...)	22	8192	100	100
TryCreateDateTimeOffset(...)	6	16	100	100
TryCreateDateTimeOffset(...)	3	4	100	100
TryCreateDateTimeOffsetInterpretingDataAsLocalTime(...)	2	2	71.43	100
TryCreateDateTime(...)	11	128	100	100
.cctor()	1	0	100	100
TryParseDateTimeOffsetO(...)	45	8388608	100	100
TryParseDateTimeOffsetR(...)	46	2	100	98.51
TryParse(...)	13	512	100	100
TryParse(...)	3	4	100	100
TryParse(...)	2	2	100	100
TryParseNormalAsFloatingPoint(...)	12	512	100	94.74
TryParseAsSpecialFloatingPoint(...)	24	8	100	100
TryParse(...)	7	32	100	100
TryParseGuidN(...)	12	64	100	100
TryParseGuidCore(...)	22	524288	100	100
TryParse(...)	13	512	100	78.95
TryParse(...)	13	512	100	78.95
TryParse(...)	13	512	100	78.95
TryParse(...)	13	512	100	78.95
TryParseSByteD(...)	18	131072	100	100
TryParseInt16D(...)	22	2097152	100	100
TryParseInt32D(...)	33	0	100	100
TryParseInt64D(...)	23	16384	100	100
TryParseSByteN(...)	18	131072	100	100
TryParseInt16N(...)	18	131072	100	100
TryParseInt32N(...)	19	262144	100	100
TryParseInt64N(...)	19	262144	100	100
TryParse(...)	13	512	100	78.95
TryParse(...)	13	512	100	78.95
TryParse(...)	13	512	100	78.95
TryParse(...)	13	512	100	78.95
TryParseByteD(...)	14	8192	100	100
TryParseUInt16D(...)	18	131072	100	100
TryParseUInt32D(...)	31	134217728	100	100
TryParseUInt64D(...)	14	1024	100	100
TryParseByteN(...)	16	32768	100	100
TryParseUInt16N(...)	16	32768	100	100
TryParseUInt32N(...)	19	32768	100	100
TryParseUInt64N(...)	19	32768	100	100
TryParseByteX(...)	11	1024	100	100
TryParseUInt16X(...)	11	1024	100	100
TryParseUInt32X(...)	11	1024	100	100
TryParseUInt64X(...)	11	1024	100	100
TryParseNumber(...)	34	268435456	100	100
TryParseTimeSpanBigG(...)	25	65536	100	100
TryParseTimeSpanC(...)	12	512	100	94.74
TryParse(...)	8	64	100	76.92
TryParseTimeSpanFraction(...)	13	224	100	100
TryCreateTimeSpan(...)	13	64	100	100
TryParseTimeSpanLittleG(...)	10	256	100	94.12
TrySplitTimeSpan(...)	24	32768	100	100
ParseComponent(...)	9	64	100	100

File(s)

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Boolean.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		/// <summary>
		10		/// Parses a Boolean at the start of a Utf8 string.
		11		/// </summary>
		12		/// <param name="text">The Utf8 string to parse</param>
		13		/// <param name="value">Receives the parsed value</param>
		14		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		15		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		16		/// <returns>
		17		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		18		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		19		/// </returns>
		20		/// <remarks>
		21		/// Formats supported:
		22		///     G (default)   True/False
		23		///     l             true/false
		24		/// </remarks>
		25		/// <exceptions>
		26		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		27		/// </exceptions>
		28		public static bool TryParse(ReadOnlySpan<byte> text, out bool value, out int bytesConsumed, char standardFormat
	1	29		{
	1	30		if (!(standardFormat == default(char) || standardFormat == 'G' || standardFormat == 'l'))
	1	31		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		32
	1	33		if (text.Length >= 4)
	1	34		{
	1	35		if ((text[0] == 'T' || text[0] == 't') &&
	1	36		(text[1] == 'R' || text[1] == 'r') &&
	1	37		(text[2] == 'U' || text[2] == 'u') &&
	1	38		(text[3] == 'E' || text[3] == 'e'))
	1	39		{
	1	40		bytesConsumed = 4;
	1	41		value = true;
	1	42		return true;
		43		}
	1	44		if (text.Length >= 5)
	1	45		{
	1	46		if ((text[0] == 'F' || text[0] == 'f') &&
	1	47		(text[1] == 'A' || text[1] == 'a') &&
	1	48		(text[2] == 'L' || text[2] == 'l') &&
	1	49		(text[3] == 'S' || text[3] == 's') &&
	1	50		(text[4] == 'E' || text[4] == 'e'))
	1	51		{
	1	52		bytesConsumed = 5;
	1	53		value = false;
	1	54		return true;
		55		}
	1	56		}
	1	57		}
	1	58		bytesConsumed = 0;
	1	59		value = default;
	1	60		return false;
	1	61		}
		62		}
		63		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.cs

	#	Line		Line coverage
		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		/// <summary>
		12		/// Parses a DateTime at the start of a Utf8 string.
		13		/// </summary>
		14		/// <param name="text">The Utf8 string to parse</param>
		15		/// <param name="value">Receives the parsed value</param>
		16		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		17		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		18		/// <returns>
		19		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		20		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		21		/// </returns>
		22		/// <remarks>
		23		/// Formats supported:
		24		///     default       05/25/2017 10:30:15 -08:00
		25		///     G             05/25/2017 10:30:15
		26		///     R             Tue, 03 Jan 2017 08:08:05 GMT       (RFC 1123)
		27		///     l             tue, 03 jan 2017 08:08:05 gmt       (Lowercase RFC 1123)
		28		///     O             2017-06-12T05:30:45.7680000-07:00   (Round-trippable)
		29		/// </remarks>
		30		/// <exceptions>
		31		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		32		/// </exceptions>
		33		public static bool TryParse(ReadOnlySpan<byte> text, out DateTime value, out int bytesConsumed, char standardFor
	1	34		{
	1	35		switch (standardFormat)
		36		{
		37		case 'R':
	1	38		{
	1	39		if (!TryParseDateTimeOffsetR(text, NoFlipCase, out DateTimeOffset dateTimeOffset, out bytesConsu
	1	40		{
	1	41		value = default;
	1	42		return false;
		43		}
	1	44		value = dateTimeOffset.DateTime;  // (returns a DateTimeKind.Unspecified to match DateTime.Parse
	1	45		return true;
		46		}
		47
		48		case 'l':
	1	49		{
	1	50		if (!TryParseDateTimeOffsetR(text, FlipCase, out DateTimeOffset dateTimeOffset, out bytesConsume
	1	51		{
	1	52		value = default;
	1	53		return false;
		54		}
	1	55		value = dateTimeOffset.DateTime;  // (returns a DateTimeKind.Unspecified to match DateTime.Parse
	1	56		return true;
		57		}
		58
		59		case 'O':
	1	60		{
		61		// Emulates DateTime.ParseExact(text, "O", CultureInfo.InvariantCulture, DateTimeStyles.Roundtri
		62		// In particular, the formatted string "encodes" the DateTimeKind according to the following tab
		63		//
		64		//         2017-06-12T05:30:45.7680000       - Unspecified
		65		//         2017-06-12T05:30:45.7680000+00:00 - Local
		66		//         2017-06-12T05:30:45.7680000Z      - Utc
		67
	1	68		if (!TryParseDateTimeOffsetO(text, out DateTimeOffset dateTimeOffset, out bytesConsumed, out Dat
	1	69		{
	1	70		value = default;
	1	71		bytesConsumed = 0;
	1	72		return false;
		73		}
		74
	1	75		switch (kind)
		76		{
		77		case DateTimeKind.Local:
	1	78		value = dateTimeOffset.LocalDateTime;
	1	79		break;
		80		case DateTimeKind.Utc:
	1	81		value = dateTimeOffset.UtcDateTime;
	1	82		break;
		83		default:
	1	84		Debug.Assert(kind == DateTimeKind.Unspecified);
	1	85		value = dateTimeOffset.DateTime;
	1	86		break;
		87		}
		88
	1	89		return true;
		90		}
		91
		92		case (default):
		93		case 'G':
	1	94		return TryParseDateTimeG(text, out value, out _, out bytesConsumed);
		95
		96		default:
	1	97		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		98		}
	1	99		}
		100
		101		/// <summary>
		102		/// Parses a DateTimeOffset at the start of a Utf8 string.
		103		/// </summary>
		104		/// <param name="text">The Utf8 string to parse</param>
		105		/// <param name="value">Receives the parsed value</param>
		106		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		107		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		108		/// <returns>
		109		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		110		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		111		/// </returns>
		112		/// <remarks>
		113		/// Formats supported:
		114		///     G  (default)  05/25/2017 10:30:15
		115		///     R             Tue, 03 Jan 2017 08:08:05 GMT       (RFC 1123)
		116		///     l             tue, 03 jan 2017 08:08:05 gmt       (Lowercase RFC 1123)
		117		///     O             2017-06-12T05:30:45.7680000-07:00   (Round-trippable)
		118		/// </remarks>
		119		/// <exceptions>
		120		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		121		/// </exceptions>
		122		public static bool TryParse(ReadOnlySpan<byte> text, out DateTimeOffset value, out int bytesConsumed, char stand
	1	123		{
	1	124		switch (standardFormat)
		125		{
		126		case 'R':
	1	127		return TryParseDateTimeOffsetR(text, NoFlipCase, out value, out bytesConsumed);
		128
		129		case 'l':
	1	130		return TryParseDateTimeOffsetR(text, FlipCase, out value, out bytesConsumed);
		131
		132		case 'O':
	1	133		return TryParseDateTimeOffsetO(text, out value, out bytesConsumed, out _);
		134
		135		case (default):
	1	136		return TryParseDateTimeOffsetDefault(text, out value, out bytesConsumed);
		137
		138		case 'G':
	1	139		return TryParseDateTimeG(text, out DateTime _, out value, out bytesConsumed);
		140
		141		default:
	1	142		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		143		}
	1	144		}
		145
		146		private const uint FlipCase = 0x00000020u;  // XOR mask to flip the case of a letter.
		147		private const uint NoFlipCase = 0x00000000u;
		148		}
		149		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.Default.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		//
		10		// ToString() format for DateTimeOffset. Does not have a corresponding format symbol but it
		11		// is the "G" format postpended with the UTC offset.
		12		//
		13		// 01234567890123456789012345
		14		// --------------------------
		15		// 05/25/2017 10:30:15 -08:00
		16		//
		17		private static bool TryParseDateTimeOffsetDefault(ReadOnlySpan<byte> text, out DateTimeOffset value, out int byt
	1	18		{
	1	19		if (text.Length < 26)
	1	20		{
	1	21		bytesConsumed = 0;
	1	22		value = default;
	1	23		return false;
		24		}
		25
	1	26		if (!TryParseDateTimeG(text, out DateTime dateTime, out _, out _))
	1	27		{
	1	28		bytesConsumed = 0;
	1	29		value = default;
	1	30		return false;
		31		}
		32
	1	33		if (text[19] != Utf8Constants.Space)
	1	34		{
	1	35		bytesConsumed = 0;
	1	36		value = default;
	1	37		return false;
		38		}
		39
	1	40		byte sign = text[20];
	1	41		if (sign != Utf8Constants.Plus && sign != Utf8Constants.Minus)
	1	42		{
	1	43		bytesConsumed = 0;
	1	44		value = default;
	1	45		return false;
		46		}
		47
		48		int offsetHours;
	1	49		{
	1	50		uint digit1 = text[21] - 48u; // '0'
	1	51		uint digit2 = text[22] - 48u; // '0'
		52
	1	53		if (digit1 > 9 || digit2 > 9)
	1	54		{
	1	55		bytesConsumed = 0;
	1	56		value = default;
	1	57		return false;
		58		}
		59
	1	60		offsetHours = (int)(digit1 * 10 + digit2);
	1	61		}
		62
	1	63		if (text[23] != Utf8Constants.Colon)
	1	64		{
	1	65		bytesConsumed = 0;
	1	66		value = default;
	1	67		return false;
		68		}
		69
		70		int offsetMinutes;
	1	71		{
	1	72		uint digit1 = text[24] - 48u; // '0'
	1	73		uint digit2 = text[25] - 48u; // '0'
		74
	1	75		if (digit1 > 9 || digit2 > 9)
	1	76		{
	1	77		bytesConsumed = 0;
	1	78		value = default;
	1	79		return false;
		80		}
		81
	1	82		offsetMinutes = (int)(digit1 * 10 + digit2);
	1	83		}
		84
	1	85		TimeSpan offset = new TimeSpan(hours: offsetHours, minutes: offsetMinutes, seconds: 0);
	1	86		if (sign == Utf8Constants.Minus)
	1	87		{
	1	88		offset = -offset;
	1	89		}
		90
	1	91		if (!TryCreateDateTimeOffset(dateTime: dateTime, offsetNegative: sign == Utf8Constants.Minus, offsetHours: o
	1	92		{
	1	93		bytesConsumed = 0;
	1	94		value = default;
	1	95		return false;
		96		}
		97
	1	98		bytesConsumed = 26;
	1	99		return true;
	1	100		}
		101		}
		102		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.G.cs

	#	Line		Line coverage
		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		//
		12		// 'G' format for DateTime.
		13		//
		14		//   0123456789012345678
		15		//   ---------------------------------
		16		//   05/25/2017 10:30:15
		17		//
		18		private static bool TryParseDateTimeG(ReadOnlySpan<byte> text, out DateTime value, out DateTimeOffset valueAsOff
	1	19		{
	1	20		if (text.Length < 19)
	1	21		{
	1	22		bytesConsumed = 0;
	1	23		value = default;
	1	24		valueAsOffset = default;
	1	25		return false;
		26		}
		27
		28		int month;
	1	29		{
	1	30		uint digit1 = text[0] - 48u; // '0'
	1	31		uint digit2 = text[1] - 48u; // '0'
		32
	1	33		if (digit1 > 9 || digit2 > 9)
	1	34		{
	1	35		bytesConsumed = 0;
	1	36		value = default;
	1	37		valueAsOffset = default;
	1	38		return false;
		39		}
		40
	1	41		month = (int)(digit1 * 10 + digit2);
	1	42		}
		43
	1	44		if (text[2] != Utf8Constants.Slash)
	1	45		{
	1	46		bytesConsumed = 0;
	1	47		value = default;
	1	48		valueAsOffset = default;
	1	49		return false;
		50		}
		51
		52		int day;
	1	53		{
	1	54		uint digit1 = text[3] - 48u; // '0'
	1	55		uint digit2 = text[4] - 48u; // '0'
		56
	1	57		if (digit1 > 9 || digit2 > 9)
	1	58		{
	1	59		bytesConsumed = 0;
	1	60		value = default;
	1	61		valueAsOffset = default;
	1	62		return false;
		63		}
		64
	1	65		day = (int)(digit1 * 10 + digit2);
	1	66		}
		67
	1	68		if (text[5] != Utf8Constants.Slash)
	1	69		{
	1	70		bytesConsumed = 0;
	1	71		value = default;
	1	72		valueAsOffset = default;
	1	73		return false;
		74		}
		75
		76		int year;
	1	77		{
	1	78		uint digit1 = text[6] - 48u; // '0'
	1	79		uint digit2 = text[7] - 48u; // '0'
	1	80		uint digit3 = text[8] - 48u; // '0'
	1	81		uint digit4 = text[9] - 48u; // '0'
		82
	1	83		if (digit1 > 9 || digit2 > 9 || digit3 > 9 || digit4 > 9)
	1	84		{
	1	85		bytesConsumed = 0;
	1	86		value = default;
	1	87		valueAsOffset = default;
	1	88		return false;
		89		}
		90
	1	91		year = (int)(digit1 * 1000 + digit2 * 100 + digit3 * 10 + digit4);
	1	92		}
		93
	1	94		if (text[10] != Utf8Constants.Space)
	1	95		{
	1	96		bytesConsumed = 0;
	1	97		value = default;
	1	98		valueAsOffset = default;
	1	99		return false;
		100		}
		101
		102		int hour;
	1	103		{
	1	104		uint digit1 = text[11] - 48u; // '0'
	1	105		uint digit2 = text[12] - 48u; // '0'
		106
	1	107		if (digit1 > 9 || digit2 > 9)
	1	108		{
	1	109		bytesConsumed = 0;
	1	110		value = default;
	1	111		valueAsOffset = default;
	1	112		return false;
		113		}
		114
	1	115		hour = (int)(digit1 * 10 + digit2);
	1	116		}
		117
	1	118		if (text[13] != Utf8Constants.Colon)
	1	119		{
	1	120		bytesConsumed = 0;
	1	121		value = default;
	1	122		valueAsOffset = default;
	1	123		return false;
		124		}
		125
		126		int minute;
	1	127		{
	1	128		uint digit1 = text[14] - 48u; // '0'
	1	129		uint digit2 = text[15] - 48u; // '0'
		130
	1	131		if (digit1 > 9 || digit2 > 9)
	1	132		{
	1	133		bytesConsumed = 0;
	1	134		value = default;
	1	135		valueAsOffset = default;
	1	136		return false;
		137		}
		138
	1	139		minute = (int)(digit1 * 10 + digit2);
	1	140		}
		141
	1	142		if (text[16] != Utf8Constants.Colon)
	1	143		{
	1	144		bytesConsumed = 0;
	1	145		value = default;
	1	146		valueAsOffset = default;
	1	147		return false;
		148		}
		149
		150		int second;
	1	151		{
	1	152		uint digit1 = text[17] - 48u; // '0'
	1	153		uint digit2 = text[18] - 48u; // '0'
		154
	1	155		if (digit1 > 9 || digit2 > 9)
	1	156		{
	1	157		bytesConsumed = 0;
	1	158		value = default;
	1	159		valueAsOffset = default;
	1	160		return false;
		161		}
		162
	1	163		second = (int)(digit1 * 10 + digit2);
	1	164		}
		165
	1	166		if (!TryCreateDateTimeOffsetInterpretingDataAsLocalTime(year: year, month: month, day: day, hour: hour, minu
	1	167		{
	1	168		bytesConsumed = 0;
	1	169		value = default;
	1	170		valueAsOffset = default;
	1	171		return false;
		172		}
		173
	1	174		bytesConsumed = 19;
	1	175		value = valueAsOffset.DateTime;
	1	176		return true;
	1	177		}
		178		}
		179		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.Helpers.cs

	#	Line		Line coverage
		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		/// <summary>
		12		/// Overflow-safe DateTimeOffset factory.
		13		/// </summary>
		14		private static bool TryCreateDateTimeOffset(DateTime dateTime, bool offsetNegative, int offsetHours, int offsetM
	1	15		{
	1	16		if (((uint)offsetHours) > Utf8Constants.DateTimeMaxUtcOffsetHours)
	1	17		{
	1	18		value = default;
	1	19		return false;
		20		}
		21
	1	22		if (((uint)offsetMinutes) > 59)
	1	23		{
	1	24		value = default;
	1	25		return false;
		26		}
		27
	1	28		if (offsetHours == Utf8Constants.DateTimeMaxUtcOffsetHours && offsetMinutes != 0)
	1	29		{
	1	30		value = default;
	1	31		return false;
		32		}
		33
	1	34		long offsetTicks = (((long)offsetHours) * 3600 + ((long)offsetMinutes) * 60) * TimeSpan.TicksPerSecond;
	1	35		if (offsetNegative)
	1	36		{
	1	37		offsetTicks = -offsetTicks;
	1	38		}
		39
		40		try
	1	41		{
	1	42		value = new DateTimeOffset(ticks: dateTime.Ticks, offset: new TimeSpan(ticks: offsetTicks));
	1	43		}
	1	44		catch (ArgumentOutOfRangeException)
	1	45		{
		46		// If we got here, the combination of the DateTime + UTC offset strayed outside the 1..9999 year range.
		47		// that it's better to catch the exception rather than replicate DateTime's range checking (which it's g
	1	48		value = default;
	1	49		return false;
		50		}
		51
	1	52		return true;
	1	53		}
		54
		55		/// <summary>
		56		/// Overflow-safe DateTimeOffset factory.
		57		/// </summary>
		58		private static bool TryCreateDateTimeOffset(int year, int month, int day, int hour, int minute, int second, int
	1	59		{
	1	60		if (!TryCreateDateTime(year: year, month: month, day: day, hour: hour, minute: minute, second: second, fract
	1	61		{
	1	62		value = default;
	1	63		return false;
		64		}
		65
	1	66		if (!TryCreateDateTimeOffset(dateTime: dateTime, offsetNegative: offsetNegative, offsetHours: offsetHours, o
	1	67		{
	1	68		value = default;
	1	69		return false;
		70		}
		71
	1	72		return true;
	1	73		}
		74
		75		/// <summary>
		76		/// Overflow-safe DateTimeOffset/Local time conversion factory.
		77		/// </summary>
		78		private static bool TryCreateDateTimeOffsetInterpretingDataAsLocalTime(int year, int month, int day, int hour, i
	1	79		{
	1	80		if (!TryCreateDateTime(year: year, month: month, day: day, hour: hour, minute: minute, second: second, fract
	1	81		{
	1	82		value = default;
	1	83		return false;
		84		}
		85
		86		try
	1	87		{
	1	88		value = new DateTimeOffset(dateTime);
	1	89		}
	0	90		catch (ArgumentOutOfRangeException)
	0	91		{
		92		// If we got here, the combination of the DateTime + UTC offset strayed outside the 1..9999 year range.
		93		// that it's better to catch the exception rather than replicate DateTime's range checking (which it's g
		94
	0	95		value = default;
	0	96		return false;
		97		}
		98
	1	99		return true;
	1	100		}
		101
		102		/// <summary>
		103		/// Overflow-safe DateTime factory.
		104		/// </summary>
		105		private static bool TryCreateDateTime(int year, int month, int day, int hour, int minute, int second, int fracti
	1	106		{
	1	107		if (year == 0)
	1	108		{
	1	109		value = default;
	1	110		return false;
		111		}
		112
	1	113		Debug.Assert(year <= 9999); // All of our callers to date parse the year from fixed 4-digit fields so this v
		114
	1	115		if ((((uint)month) - 1) >= 12)
	1	116		{
	1	117		value = default;
	1	118		return false;
		119		}
		120
	1	121		uint dayMinusOne = ((uint)day) - 1;
	1	122		if (dayMinusOne >= 28 && dayMinusOne >= DateTime.DaysInMonth(year, month))
	1	123		{
	1	124		value = default;
	1	125		return false;
		126		}
		127
	1	128		if (((uint)hour) > 23)
	1	129		{
	1	130		value = default;
	1	131		return false;
		132		}
		133
	1	134		if (((uint)minute) > 59)
	1	135		{
	1	136		value = default;
	1	137		return false;
		138		}
		139
	1	140		if (((uint)second) > 59)
	1	141		{
	1	142		value = default;
	1	143		return false;
		144		}
		145
	1	146		Debug.Assert(fraction >= 0 && fraction <= Utf8Constants.MaxDateTimeFraction); // All of our callers to date
		147
	1	148		int[] days = DateTime.IsLeapYear(year) ? s_daysToMonth366 : s_daysToMonth365;
	1	149		int yearMinusOne = year - 1;
	1	150		int totalDays = (yearMinusOne * 365) + (yearMinusOne / 4) - (yearMinusOne / 100) + (yearMinusOne / 400) + da
	1	151		long ticks = totalDays * TimeSpan.TicksPerDay;
	1	152		int totalSeconds = (hour * 3600) + (minute * 60) + second;
	1	153		ticks += totalSeconds * TimeSpan.TicksPerSecond;
	1	154		ticks += fraction;
	1	155		value = new DateTime(ticks: ticks, kind: kind);
	1	156		return true;
	1	157		}
		158
	1	159		private static readonly int[] s_daysToMonth365 = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
	1	160		private static readonly int[] s_daysToMonth366 = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
		161		}
		162		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.O.cs

	#	Line		Line coverage
		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		//
		12		// Roundtrippable format. One of
		13		//
		14		//   012345678901234567890123456789012
		15		//   ---------------------------------
		16		//   2017-06-12T05:30:45.7680000-07:00
		17		//   2017-06-12T05:30:45.7680000Z           (Z is short for "+00:00" but also distinguishes DateTimeKind.Utc fro
		18		//   2017-06-12T05:30:45.7680000            (interpreted as local time wrt to current time zone)
		19		//
		20		private static bool TryParseDateTimeOffsetO(ReadOnlySpan<byte> text, out DateTimeOffset value, out int bytesCons
	1	21		{
	1	22		if (text.Length < 27)
	1	23		{
	1	24		value = default;
	1	25		bytesConsumed = 0;
	1	26		kind = default;
	1	27		return false;
		28		}
		29
		30		int year;
	1	31		{
	1	32		uint digit1 = text[0] - 48u; // '0'
	1	33		uint digit2 = text[1] - 48u; // '0'
	1	34		uint digit3 = text[2] - 48u; // '0'
	1	35		uint digit4 = text[3] - 48u; // '0'
		36
	1	37		if (digit1 > 9 || digit2 > 9 || digit3 > 9 || digit4 > 9)
	1	38		{
	1	39		value = default;
	1	40		bytesConsumed = 0;
	1	41		kind = default;
	1	42		return false;
		43		}
		44
	1	45		year = (int)(digit1 * 1000 + digit2 * 100 + digit3 * 10 + digit4);
	1	46		}
		47
	1	48		if (text[4] != Utf8Constants.Hyphen)
	1	49		{
	1	50		value = default;
	1	51		bytesConsumed = 0;
	1	52		kind = default;
	1	53		return false;
		54		}
		55
		56		int month;
	1	57		{
	1	58		uint digit1 = text[5] - 48u; // '0'
	1	59		uint digit2 = text[6] - 48u; // '0'
		60
	1	61		if (digit1 > 9 || digit2 > 9)
	1	62		{
	1	63		value = default;
	1	64		bytesConsumed = 0;
	1	65		kind = default;
	1	66		return false;
		67		}
		68
	1	69		month = (int)(digit1 * 10 + digit2);
	1	70		}
		71
	1	72		if (text[7] != Utf8Constants.Hyphen)
	1	73		{
	1	74		value = default;
	1	75		bytesConsumed = 0;
	1	76		kind = default;
	1	77		return false;
		78		}
		79
		80		int day;
	1	81		{
	1	82		uint digit1 = text[8] - 48u; // '0'
	1	83		uint digit2 = text[9] - 48u; // '0'
		84
	1	85		if (digit1 > 9 || digit2 > 9)
	1	86		{
	1	87		value = default;
	1	88		bytesConsumed = 0;
	1	89		kind = default;
	1	90		return false;
		91		}
		92
	1	93		day = (int)(digit1 * 10 + digit2);
	1	94		}
		95
	1	96		if (text[10] != 'T')
	1	97		{
	1	98		value = default;
	1	99		bytesConsumed = 0;
	1	100		kind = default;
	1	101		return false;
		102		}
		103
		104		int hour;
	1	105		{
	1	106		uint digit1 = text[11] - 48u; // '0'
	1	107		uint digit2 = text[12] - 48u; // '0'
		108
	1	109		if (digit1 > 9 || digit2 > 9)
	1	110		{
	1	111		value = default;
	1	112		bytesConsumed = 0;
	1	113		kind = default;
	1	114		return false;
		115		}
		116
	1	117		hour = (int)(digit1 * 10 + digit2);
	1	118		}
		119
	1	120		if (text[13] != Utf8Constants.Colon)
	1	121		{
	1	122		value = default;
	1	123		bytesConsumed = 0;
	1	124		kind = default;
	1	125		return false;
		126		}
		127
		128		int minute;
	1	129		{
	1	130		uint digit1 = text[14] - 48u; // '0'
	1	131		uint digit2 = text[15] - 48u; // '0'
		132
	1	133		if (digit1 > 9 || digit2 > 9)
	1	134		{
	1	135		value = default;
	1	136		bytesConsumed = 0;
	1	137		kind = default;
	1	138		return false;
		139		}
		140
	1	141		minute = (int)(digit1 * 10 + digit2);
	1	142		}
		143
	1	144		if (text[16] != Utf8Constants.Colon)
	1	145		{
	1	146		value = default;
	1	147		bytesConsumed = 0;
	1	148		kind = default;
	1	149		return false;
		150		}
		151
		152		int second;
	1	153		{
	1	154		uint digit1 = text[17] - 48u; // '0'
	1	155		uint digit2 = text[18] - 48u; // '0'
		156
	1	157		if (digit1 > 9 || digit2 > 9)
	1	158		{
	1	159		value = default;
	1	160		bytesConsumed = 0;
	1	161		kind = default;
	1	162		return false;
		163		}
		164
	1	165		second = (int)(digit1 * 10 + digit2);
	1	166		}
		167
	1	168		if (text[19] != Utf8Constants.Period)
	1	169		{
	1	170		value = default;
	1	171		bytesConsumed = 0;
	1	172		kind = default;
	1	173		return false;
		174		}
		175
		176		int fraction;
	1	177		{
	1	178		uint digit1 = text[20] - 48u; // '0'
	1	179		uint digit2 = text[21] - 48u; // '0'
	1	180		uint digit3 = text[22] - 48u; // '0'
	1	181		uint digit4 = text[23] - 48u; // '0'
	1	182		uint digit5 = text[24] - 48u; // '0'
	1	183		uint digit6 = text[25] - 48u; // '0'
	1	184		uint digit7 = text[26] - 48u; // '0'
		185
	1	186		if (digit1 > 9 || digit2 > 9 || digit3 > 9 || digit4 > 9 || digit5 > 9 || digit6 > 9 || digit7 > 9)
	1	187		{
	1	188		value = default;
	1	189		bytesConsumed = 0;
	1	190		kind = default;
	1	191		return false;
		192		}
		193
	1	194		fraction = (int)(digit1 * 1000000 + digit2 * 100000 + digit3 * 10000 + digit4 * 1000 + digit5 * 100 + di
	1	195		}
		196
	1	197		byte offsetChar = (text.Length <= 27) ? default : text[27];
	1	198		if (offsetChar != 'Z' && offsetChar != Utf8Constants.Plus && offsetChar != Utf8Constants.Minus)
	1	199		{
	1	200		if (!TryCreateDateTimeOffsetInterpretingDataAsLocalTime(year: year, month: month, day: day, hour: hour,
	1	201		{
	1	202		value = default;
	1	203		bytesConsumed = 0;
	1	204		kind = default;
	1	205		return false;
		206		}
	1	207		bytesConsumed = 27;
	1	208		kind = DateTimeKind.Unspecified;
	1	209		return true;
		210		}
		211
	1	212		if (offsetChar == 'Z')
	1	213		{
		214		// Same as specifying an offset of "+00:00", except that DateTime's Kind gets set to UTC rather than Loc
	1	215		if (!TryCreateDateTimeOffset(year: year, month: month, day: day, hour: hour, minute: minute, second: sec
	1	216		{
	1	217		value = default;
	1	218		bytesConsumed = 0;
	1	219		kind = default;
	1	220		return false;
		221		}
		222
	1	223		bytesConsumed = 28;
	1	224		kind = DateTimeKind.Utc;
	1	225		return true;
		226		}
		227
	1	228		Debug.Assert(offsetChar == Utf8Constants.Plus || offsetChar == Utf8Constants.Minus);
	1	229		if (text.Length < 33)
	1	230		{
	1	231		value = default;
	1	232		bytesConsumed = 0;
	1	233		kind = default;
	1	234		return false;
		235		}
		236
		237		int offsetHours;
	1	238		{
	1	239		uint digit1 = text[28] - 48u; // '0'
	1	240		uint digit2 = text[29] - 48u; // '0'
		241
	1	242		if (digit1 > 9 || digit2 > 9)
	1	243		{
	1	244		value = default;
	1	245		bytesConsumed = 0;
	1	246		kind = default;
	1	247		return false;
		248		}
		249
	1	250		offsetHours = (int)(digit1 * 10 + digit2);
	1	251		}
		252
	1	253		if (text[30] != Utf8Constants.Colon)
	1	254		{
	1	255		value = default;
	1	256		bytesConsumed = 0;
	1	257		kind = default;
	1	258		return false;
		259		}
		260
		261		int offsetMinutes;
	1	262		{
	1	263		uint digit1 = text[31] - 48u; // '0'
	1	264		uint digit2 = text[32] - 48u; // '0'
		265
	1	266		if (digit1 > 9 || digit2 > 9)
	1	267		{
	1	268		value = default;
	1	269		bytesConsumed = 0;
	1	270		kind = default;
	1	271		return false;
		272		}
		273
	1	274		offsetMinutes = (int)(digit1 * 10 + digit2);
	1	275		}
		276
	1	277		if (!TryCreateDateTimeOffset(year: year, month: month, day: day, hour: hour, minute: minute, second: second,
	1	278		{
	1	279		value = default;
	1	280		bytesConsumed = 0;
	1	281		kind = default;
	1	282		return false;
		283		}
		284
	1	285		bytesConsumed = 33;
	1	286		kind = DateTimeKind.Local;
	1	287		return true;
	1	288		}
		289		}
		290		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Date.R.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		//
		10		// Parse an RFC1123 date string.
		11		//
		12		// 01234567890123456789012345678
		13		// -----------------------------
		14		// Tue, 03 Jan 2017 08:08:05 GMT
		15		//
		16		private static bool TryParseDateTimeOffsetR(ReadOnlySpan<byte> text, uint caseFlipXorMask, out DateTimeOffset da
	1	17		{
	1	18		if (text.Length < 29)
	1	19		{
	1	20		bytesConsumed = 0;
	1	21		dateTimeOffset = default;
	1	22		return false;
		23		}
		24
		25		DayOfWeek dayOfWeek;
	1	26		{
	1	27		uint dow0 = text[0] ^ caseFlipXorMask;
	1	28		uint dow1 = text[1];
	1	29		uint dow2 = text[2];
	1	30		uint comma = text[3];
	1	31		uint dowString = (dow0 << 24) | (dow1 << 16) | (dow2 << 8) | comma;
	1	32		switch (dowString)
		33		{
	2	34		case 0x53756E2c /* 'Sun,' */: dayOfWeek = DayOfWeek.Sunday; break;
	2	35		case 0x4d6f6e2c /* 'Mon,' */: dayOfWeek = DayOfWeek.Monday; break;
	2	36		case 0x5475652c /* 'Tue,' */: dayOfWeek = DayOfWeek.Tuesday; break;
	2	37		case 0x5765642c /* 'Wed,' */: dayOfWeek = DayOfWeek.Wednesday; break;
	2	38		case 0x5468752c /* 'Thu,' */: dayOfWeek = DayOfWeek.Thursday; break;
	2	39		case 0x4672692c /* 'Fri,' */: dayOfWeek = DayOfWeek.Friday; break;
	2	40		case 0x5361742c /* 'Sat,' */: dayOfWeek = DayOfWeek.Saturday; break;
		41		default:
	1	42		bytesConsumed = 0;
	1	43		dateTimeOffset = default;
	1	44		return false;
		45		}
	1	46		}
		47
	1	48		if (text[4] != Utf8Constants.Space)
	1	49		{
	1	50		bytesConsumed = 0;
	1	51		dateTimeOffset = default;
	1	52		return false;
		53		}
		54
		55		int day;
	1	56		{
	1	57		uint digit1 = text[5] - 48u; // '0'
	1	58		uint digit2 = text[6] - 48u; // '0'
		59
	1	60		if (digit1 > 9 || digit2 > 9)
	1	61		{
	1	62		bytesConsumed = 0;
	1	63		dateTimeOffset = default;
	1	64		return false;
		65		}
		66
	1	67		day = (int)(digit1 * 10 + digit2);
	1	68		}
		69
	1	70		if (text[7] != Utf8Constants.Space)
	1	71		{
	1	72		bytesConsumed = 0;
	1	73		dateTimeOffset = default;
	1	74		return false;
		75		}
		76
		77		int month;
	1	78		{
	1	79		uint mon0 = text[8] ^ caseFlipXorMask;
	1	80		uint mon1 = text[9];
	1	81		uint mon2 = text[10];
	1	82		uint space = text[11];
	1	83		uint monthString = (mon0 << 24) | (mon1 << 16) | (mon2 << 8) | space;
	1	84		switch (monthString)
		85		{
	2	86		case 0x4a616e20 /* 'Jan ' */ : month = 1; break;
	2	87		case 0x46656220 /* 'Feb ' */ : month = 2; break;
	2	88		case 0x4d617220 /* 'Mar ' */ : month = 3; break;
	2	89		case 0x41707220 /* 'Apr ' */ : month = 4; break;
	2	90		case 0x4d617920 /* 'May ' */ : month = 5; break;
	2	91		case 0x4a756e20 /* 'Jun ' */ : month = 6; break;
	2	92		case 0x4a756c20 /* 'Jul ' */ : month = 7; break;
	2	93		case 0x41756720 /* 'Aug ' */ : month = 8; break;
	2	94		case 0x53657020 /* 'Sep ' */ : month = 9; break;
	2	95		case 0x4f637420 /* 'Oct ' */ : month = 10; break;
	2	96		case 0x4e6f7620 /* 'Nov ' */ : month = 11; break;
	2	97		case 0x44656320 /* 'Dec ' */ : month = 12; break;
		98		default:
	1	99		bytesConsumed = 0;
	1	100		dateTimeOffset = default;
	1	101		return false;
		102		}
	1	103		}
		104
		105		int year;
	1	106		{
	1	107		uint digit1 = text[12] - 48u; // '0'
	1	108		uint digit2 = text[13] - 48u; // '0'
	1	109		uint digit3 = text[14] - 48u; // '0'
	1	110		uint digit4 = text[15] - 48u; // '0'
		111
	1	112		if (digit1 > 9 || digit2 > 9 || digit3 > 9 || digit4 > 9)
	1	113		{
	1	114		bytesConsumed = 0;
	1	115		dateTimeOffset = default;
	1	116		return false;
		117		}
		118
	1	119		year = (int)(digit1 * 1000 + digit2 * 100 + digit3 * 10 + digit4);
	1	120		}
		121
	1	122		if (text[16] != Utf8Constants.Space)
	1	123		{
	1	124		bytesConsumed = 0;
	1	125		dateTimeOffset = default;
	1	126		return false;
		127		}
		128
		129		int hour;
	1	130		{
	1	131		uint digit1 = text[17] - 48u; // '0'
	1	132		uint digit2 = text[18] - 48u; // '0'
		133
	1	134		if (digit1 > 9 || digit2 > 9)
	1	135		{
	1	136		bytesConsumed = 0;
	1	137		dateTimeOffset = default;
	1	138		return false;
		139		}
		140
	1	141		hour = (int)(digit1 * 10 + digit2);
	1	142		}
		143
	1	144		if (text[19] != Utf8Constants.Colon)
	1	145		{
	1	146		bytesConsumed = 0;
	1	147		dateTimeOffset = default;
	1	148		return false;
		149		}
		150
		151		int minute;
	1	152		{
	1	153		uint digit1 = text[20] - 48u; // '0'
	1	154		uint digit2 = text[21] - 48u; // '0'
		155
	1	156		if (digit1 > 9 || digit2 > 9)
	1	157		{
	1	158		bytesConsumed = 0;
	1	159		dateTimeOffset = default;
	1	160		return false;
		161		}
		162
	1	163		minute = (int)(digit1 * 10 + digit2);
	1	164		}
		165
	1	166		if (text[22] != Utf8Constants.Colon)
	1	167		{
	1	168		bytesConsumed = 0;
	1	169		dateTimeOffset = default;
	1	170		return false;
		171		}
		172
		173		int second;
	1	174		{
	1	175		uint digit1 = text[23] - 48u; // '0'
	1	176		uint digit2 = text[24] - 48u; // '0'
		177
	1	178		if (digit1 > 9 || digit2 > 9)
	1	179		{
	1	180		bytesConsumed = 0;
	1	181		dateTimeOffset = default;
	1	182		return false;
		183		}
		184
	1	185		second = (int)(digit1 * 10 + digit2);
	1	186		}
		187
	1	188		{
	1	189		uint space = text[25];
	1	190		uint g = text[26] ^ caseFlipXorMask;
	1	191		uint m = text[27] ^ caseFlipXorMask;
	1	192		uint t = text[28] ^ caseFlipXorMask;
	1	193		uint gmtString = (space << 24) | (g << 16) | (m << 8) | t;
	1	194		if (gmtString != 0x20474d54 /* ' GMT' */)
	1	195		{
	1	196		bytesConsumed = 0;
	1	197		dateTimeOffset = default;
	1	198		return false;
		199		}
	1	200		}
		201
	1	202		if (!TryCreateDateTimeOffset(year: year, month: month, day: day, hour: hour, minute: minute, second: second,
	1	203		{
	1	204		bytesConsumed = 0;
	1	205		dateTimeOffset = default;
	1	206		return false;
		207		}
		208
	1	209		if (dayOfWeek != dateTimeOffset.DayOfWeek)
	1	210		{
		211		// If we got here, the day of week did not match the actual date.
	1	212		bytesConsumed = 0;
	1	213		dateTimeOffset = default;
	1	214		return false;
		215		}
		216
	1	217		bytesConsumed = 29;
	1	218		return true;
	1	219		}
		220		}
		221		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Decimal.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		/// <summary>
		10		/// Parses a Decimal at the start of a Utf8 string.
		11		/// </summary>
		12		/// <param name="text">The Utf8 string to parse</param>
		13		/// <param name="value">Receives the parsed value</param>
		14		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		15		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		16		/// <returns>
		17		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		18		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		19		/// </returns>
		20		/// <remarks>
		21		/// Formats supported:
		22		///     G/g  (default)
		23		///     F/f             12.45       Fixed point
		24		///     E/e             1.245000e1  Exponential
		25		/// </remarks>
		26		/// <exceptions>
		27		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		28		/// </exceptions>
		29		public static bool TryParse(ReadOnlySpan<byte> text, out decimal value, out int bytesConsumed, char standardForm
	1	30		{
		31		ParseNumberOptions options;
	1	32		switch (standardFormat)
		33		{
		34		case (default):
		35		case 'G':
		36		case 'g':
		37		case 'E':
		38		case 'e':
	1	39		options = ParseNumberOptions.AllowExponent;
	1	40		break;
		41
		42		case 'F':
		43		case 'f':
	1	44		options = default;
	1	45		break;
		46
		47		default:
	1	48		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		49		}
		50
	1	51		NumberBuffer number = default;
	1	52		if (!TryParseNumber(text, ref number, out bytesConsumed, options, out bool textUsedExponentNotation))
	1	53		{
	1	54		value = default;
	1	55		return false;
		56		}
		57
	1	58		if ((!textUsedExponentNotation) && (standardFormat == 'E' || standardFormat == 'e'))
	1	59		{
	1	60		value = default;
	1	61		bytesConsumed = 0;
	1	62		return false;
		63		}
		64
		65		// More compat with .NET behavior - whether or not a 0 keeps the negative sign depends on whether it an "int
	1	66		if (number.Digits[0] == 0 && number.Scale == 0)
	1	67		{
	1	68		number.IsNegative = false;
	1	69		}
		70
	1	71		value = default;
	1	72		if (!Number.NumberBufferToDecimal(ref number, ref value))
	1	73		{
	1	74		value = default;
	1	75		bytesConsumed = 0;
	1	76		return false;
		77		}
		78
	1	79		return true;
	1	80		}
		81		}
		82		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Float.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		/// <summary>
		10		/// Parses a Single at the start of a Utf8 string.
		11		/// </summary>
		12		/// <param name="text">The Utf8 string to parse</param>
		13		/// <param name="value">Receives the parsed value</param>
		14		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		15		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		16		/// <returns>
		17		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		18		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		19		/// </returns>
		20		/// <remarks>
		21		/// Formats supported:
		22		///     G/g  (default)
		23		///     F/f             12.45       Fixed point
		24		///     E/e             1.245000e1  Exponential
		25		/// </remarks>
		26		/// <exceptions>
		27		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		28		/// </exceptions>
		29		public static bool TryParse(ReadOnlySpan<byte> text, out float value, out int bytesConsumed, char standardFormat
	1	30		{
	1	31		if (TryParseNormalAsFloatingPoint(text, out double d, out bytesConsumed, standardFormat))
	1	32		{
	1	33		value = (float)d;
	1	34		if (float.IsInfinity(value))
	1	35		{
	1	36		value = default;
	1	37		bytesConsumed = 0;
	1	38		return false;
		39		}
	1	40		return true;
		41		}
		42
	1	43		return TryParseAsSpecialFloatingPoint<float>(text, float.PositiveInfinity, float.NegativeInfinity, float.NaN
	1	44		}
		45
		46		/// <summary>
		47		/// Parses a Double at the start of a Utf8 string.
		48		/// </summary>
		49		/// <param name="text">The Utf8 string to parse</param>
		50		/// <param name="value">Receives the parsed value</param>
		51		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		52		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		53		/// <returns>
		54		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		55		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		56		/// </returns>
		57		/// <remarks>
		58		/// Formats supported:
		59		///     G/g  (default)
		60		///     F/f             12.45       Fixed point
		61		///     E/e             1.245000e1  Exponential
		62		/// </remarks>
		63		/// <exceptions>
		64		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		65		/// </exceptions>
		66		public static bool TryParse(ReadOnlySpan<byte> text, out double value, out int bytesConsumed, char standardForma
	1	67		{
	1	68		if (TryParseNormalAsFloatingPoint(text, out value, out bytesConsumed, standardFormat))
	1	69		return true;
		70
	1	71		return TryParseAsSpecialFloatingPoint<double>(text, double.PositiveInfinity, double.NegativeInfinity, double
	1	72		}
		73
		74		//
		75		// Attempt to parse the regular floating points (the ones without names like "Infinity" and "NaN")
		76		//
		77		private static bool TryParseNormalAsFloatingPoint(ReadOnlySpan<byte> text, out double value, out int bytesConsum
	1	78		{
		79		ParseNumberOptions options;
	1	80		switch (standardFormat)
		81		{
		82		case (default):
		83		case 'G':
		84		case 'g':
		85		case 'E':
		86		case 'e':
	1	87		options = ParseNumberOptions.AllowExponent;
	1	88		break;
		89
		90		case 'F':
		91		case 'f':
	1	92		options = default;
	1	93		break;
		94
		95		default:
	1	96		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		97		}
		98
	1	99		NumberBuffer number = default;
	1	100		if (!TryParseNumber(text, ref number, out bytesConsumed, options, out bool textUsedExponentNotation))
	1	101		{
	1	102		value = default;
	1	103		return false;
		104		}
		105
	1	106		if ((!textUsedExponentNotation) && (standardFormat == 'E' || standardFormat == 'e'))
	1	107		{
	1	108		value = default;
	1	109		bytesConsumed = 0;
	1	110		return false;
		111		}
		112
	1	113		if (number.Digits[0] == 0)
	1	114		{
	1	115		number.IsNegative = false;
	1	116		}
		117
	1	118		if (!Number.NumberBufferToDouble(ref number, out value))
	1	119		{
	1	120		value = default;
	1	121		bytesConsumed = 0;
	1	122		return false;
		123		}
		124
	1	125		return true;
	1	126		}
		127
		128		//
		129		// Assuming the text doesn't look like a normal floating point, we attempt to parse it as one the special floati
		130		//
		131		private static bool TryParseAsSpecialFloatingPoint<T>(ReadOnlySpan<byte> text, T positiveInfinity, T negativeInf
	1	132		{
	1	133		if (text.Length >= 8 &&
	1	134		text[0] == 'I' && text[1] == 'n' && text[2] == 'f' && text[3] == 'i' &&
	1	135		text[4] == 'n' && text[5] == 'i' && text[6] == 't' && text[7] == 'y')
	1	136		{
	1	137		value = positiveInfinity;
	1	138		bytesConsumed = 8;
	1	139		return true;
		140		}
		141
	1	142		if (text.Length >= 9 &&
	1	143		text[0] == Utf8Constants.Minus &&
	1	144		text[1] == 'I' && text[2] == 'n' && text[3] == 'f' && text[4] == 'i' &&
	1	145		text[5] == 'n' && text[6] == 'i' && text[7] == 't' && text[8] == 'y')
	1	146		{
	1	147		value = negativeInfinity;
	1	148		bytesConsumed = 9;
	1	149		return true;
		150		}
		151
	1	152		if (text.Length >= 3 &&
	1	153		text[0] == 'N' && text[1] == 'a' && text[2] == 'N')
	1	154		{
	1	155		value = nan;
	1	156		bytesConsumed = 3;
	1	157		return true;
		158		}
		159
	1	160		value = default;
	1	161		bytesConsumed = 0;
	1	162		return false;
	1	163		}
		164		}
		165		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Guid.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		/// <summary>
		10		/// Parses a Guid at the start of a Utf8 string.
		11		/// </summary>
		12		/// <param name="text">The Utf8 string to parse</param>
		13		/// <param name="value">Receives the parsed value</param>
		14		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		15		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		16		/// <returns>
		17		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		18		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		19		/// </returns>
		20		/// <remarks>
		21		/// Formats supported:
		22		///     D (default)     nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn
		23		///     B               {nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn}
		24		///     P               (nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn)
		25		///     N               nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
		26		/// </remarks>
		27		/// <exceptions>
		28		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		29		/// </exceptions>
		30		public static bool TryParse(ReadOnlySpan<byte> text, out Guid value, out int bytesConsumed, char standardFormat
	1	31		{
	1	32		switch (standardFormat)
		33		{
		34		case (default):
		35		case 'D':
	1	36		return TryParseGuidCore(text, false, ' ', ' ', out value, out bytesConsumed);
		37		case 'B':
	1	38		return TryParseGuidCore(text, true, '{', '}', out value, out bytesConsumed);
		39		case 'P':
	1	40		return TryParseGuidCore(text, true, '(', ')', out value, out bytesConsumed);
		41		case 'N':
	1	42		return TryParseGuidN(text, out value, out bytesConsumed);
		43		default:
	1	44		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		45		}
	1	46		}
		47
		48		// nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn (not very Guid-like, but the format is what it is...)
		49		private static bool TryParseGuidN(ReadOnlySpan<byte> text, out Guid value, out int bytesConsumed)
	1	50		{
	1	51		if (text.Length < 32)
	1	52		{
	1	53		value = default;
	1	54		bytesConsumed = 0;
	1	55		return false;
		56		}
		57
	1	58		if (!TryParseUInt32X(text.Slice(0, 8), out uint i1, out int justConsumed) || justConsumed != 8)
	1	59		{
	1	60		value = default;
	1	61		bytesConsumed = 0;
	1	62		return false; // 8 digits
		63		}
		64
	1	65		if (!TryParseUInt16X(text.Slice(8, 4), out ushort i2, out justConsumed) || justConsumed != 4)
	1	66		{
	1	67		value = default;
	1	68		bytesConsumed = 0;
	1	69		return false; // next 4 digits
		70		}
		71
	1	72		if (!TryParseUInt16X(text.Slice(12, 4), out ushort i3, out justConsumed) || justConsumed != 4)
	1	73		{
	1	74		value = default;
	1	75		bytesConsumed = 0;
	1	76		return false; // next 4 digits
		77		}
		78
	1	79		if (!TryParseUInt16X(text.Slice(16, 4), out ushort i4, out justConsumed) || justConsumed != 4)
	1	80		{
	1	81		value = default;
	1	82		bytesConsumed = 0;
	1	83		return false; // next 4 digits
		84		}
		85
	1	86		if (!TryParseUInt64X(text.Slice(20), out ulong i5, out justConsumed) || justConsumed != 12)
	1	87		{
	1	88		value = default;
	1	89		bytesConsumed = 0;
	1	90		return false; // next 4 digits
		91		}
		92
	1	93		bytesConsumed = 32;
	1	94		value = new Guid((int)i1, (short)i2, (short)i3, (byte)(i4 >> 8), (byte)i4,
	1	95		(byte)(i5 >> 40), (byte)(i5 >> 32), (byte)(i5 >> 24), (byte)(i5 >> 16), (byte)(i5 >> 8), (byte)i5);
	1	96		return true;
	1	97		}
		98
		99		// {8-4-4-4-12}, where number is the number of hex digits, and {/} are ends.
		100		private static bool TryParseGuidCore(ReadOnlySpan<byte> text, bool ends, char begin, char end, out Guid value, o
	1	101		{
	1	102		int expectedCodingUnits = 36 + (ends ? 2 : 0); // 32 hex digits + 4 delimiters + 2 optional ends
		103
	1	104		if (text.Length < expectedCodingUnits)
	1	105		{
	1	106		value = default;
	1	107		bytesConsumed = 0;
	1	108		return false;
		109		}
		110
	1	111		if (ends)
	1	112		{
	1	113		if (text[0] != begin)
	1	114		{
	1	115		value = default;
	1	116		bytesConsumed = 0;
	1	117		return false;
		118		}
		119
	1	120		text = text.Slice(1); // skip begining
	1	121		}
		122
	1	123		if (!TryParseUInt32X(text, out uint i1, out int justConsumed))
	1	124		{
	1	125		value = default;
	1	126		bytesConsumed = 0;
	1	127		return false;
		128		}
		129
	1	130		if (justConsumed != 8)
	1	131		{
	1	132		value = default;
	1	133		bytesConsumed = 0;
	1	134		return false; // 8 digits
		135		}
		136
	1	137		if (text[justConsumed] != '-')
	1	138		{
	1	139		value = default;
	1	140		bytesConsumed = 0;
	1	141		return false;
		142		}
		143
	1	144		text = text.Slice(9); // justConsumed + 1 for delimiter
		145
	1	146		if (!TryParseUInt16X(text, out ushort i2, out justConsumed))
	1	147		{
	1	148		value = default;
	1	149		bytesConsumed = 0;
	1	150		return false;
		151		}
		152
	1	153		if (justConsumed != 4)
	1	154		{
	1	155		value = default;
	1	156		bytesConsumed = 0;
	1	157		return false; // 4 digits
		158		}
		159
	1	160		if (text[justConsumed] != '-')
	1	161		{
	1	162		value = default;
	1	163		bytesConsumed = 0;
	1	164		return false;
		165		}
		166
	1	167		text = text.Slice(5); // justConsumed + 1 for delimiter
		168
	1	169		if (!TryParseUInt16X(text, out ushort i3, out justConsumed))
	1	170		{
	1	171		value = default;
	1	172		bytesConsumed = 0;
	1	173		return false;
		174		}
		175
	1	176		if (justConsumed != 4)
	1	177		{
	1	178		value = default;
	1	179		bytesConsumed = 0;
	1	180		return false; // 4 digits
		181		}
		182
	1	183		if (text[justConsumed] != '-')
	1	184		{
	1	185		value = default;
	1	186		bytesConsumed = 0;
	1	187		return false;
		188		}
		189
	1	190		text = text.Slice(5); // justConsumed + 1 for delimiter
		191
	1	192		if (!TryParseUInt16X(text, out ushort i4, out justConsumed))
	1	193		{
	1	194		value = default;
	1	195		bytesConsumed = 0;
	1	196		return false;
		197		}
		198
	1	199		if (justConsumed != 4)
	1	200		{
	1	201		value = default;
	1	202		bytesConsumed = 0;
	1	203		return false; // 4 digits
		204		}
		205
	1	206		if (text[justConsumed] != '-')
	1	207		{
	1	208		value = default;
	1	209		bytesConsumed = 0;
	1	210		return false;
		211		}
		212
	1	213		text = text.Slice(5);// justConsumed + 1 for delimiter
		214
	1	215		if (!TryParseUInt64X(text, out ulong i5, out justConsumed))
	1	216		{
	1	217		value = default;
	1	218		bytesConsumed = 0;
	1	219		return false;
		220		}
		221
	1	222		if (justConsumed != 12)
	1	223		{
	1	224		value = default;
	1	225		bytesConsumed = 0;
	1	226		return false; // 12 digits
		227		}
		228
	1	229		if (ends && text[justConsumed] != end)
	1	230		{
	1	231		value = default;
	1	232		bytesConsumed = 0;
	1	233		return false;
		234		}
		235
	1	236		bytesConsumed = expectedCodingUnits;
	1	237		value = new Guid((int)i1, (short)i2, (short)i3, (byte)(i4 >> 8), (byte)i4,
	1	238		(byte)(i5 >> 40), (byte)(i5 >> 32), (byte)(i5 >> 24), (byte)(i5 >> 16), (byte)(i5 >> 8), (byte)i5);
		239
	1	240		return true;
	1	241		}
		242		}
		243		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.cs

	#	Line		Line coverage
		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		#if !netstandard
		6		using Internal.Runtime.CompilerServices;
		7		#else
		8		using System.Runtime.CompilerServices;
		9		#endif
		10
		11		namespace System.Buffers.Text
		12		{
		13		/// <summary>
		14		/// Methods to parse common data types to Utf8 strings.
		15		/// </summary>
		16		public static partial class Utf8Parser
		17		{
		18		/// <summary>
		19		/// Parses a SByte at the start of a Utf8 string.
		20		/// </summary>
		21		/// <param name="text">The Utf8 string to parse</param>
		22		/// <param name="value">Receives the parsed value</param>
		23		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		24		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		25		/// <returns>
		26		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		27		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		28		/// </returns>
		29		/// <remarks>
		30		/// Formats supported:
		31		///     G/g (default)
		32		///     D/d             32767
		33		///     N/n             32,767
		34		///     X/x             7fff
		35		/// </remarks>
		36		/// <exceptions>
		37		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		38		/// </exceptions>
		39		[CLSCompliant(false)]
		40		public static bool TryParse(ReadOnlySpan<byte> text, out sbyte value, out int bytesConsumed, char standardFormat
	1	41		{
	1	42		switch (standardFormat)
		43		{
		44		case (default):
		45		case 'g':
		46		case 'G':
		47		case 'd':
		48		case 'D':
	1	49		return TryParseSByteD(text, out value, out bytesConsumed);
		50
		51		case 'n':
		52		case 'N':
	1	53		return TryParseSByteN(text, out value, out bytesConsumed);
		54
		55		case 'x':
		56		case 'X':
	1	57		value = default;
	1	58		return TryParseByteX(text, out Unsafe.As<sbyte, byte>(ref value), out bytesConsumed);
		59
		60		default:
	1	61		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		62		}
	1	63		}
		64
		65		/// <summary>
		66		/// Parses an Int16 at the start of a Utf8 string.
		67		/// </summary>
		68		/// <param name="text">The Utf8 string to parse</param>
		69		/// <param name="value">Receives the parsed value</param>
		70		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		71		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		72		/// <returns>
		73		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		74		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		75		/// </returns>
		76		/// <remarks>
		77		/// Formats supported:
		78		///     G/g (default)
		79		///     D/d             32767
		80		///     N/n             32,767
		81		///     X/x             7fff
		82		/// </remarks>
		83		/// <exceptions>
		84		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		85		/// </exceptions>
		86		public static bool TryParse(ReadOnlySpan<byte> text, out short value, out int bytesConsumed, char standardFormat
	1	87		{
	1	88		switch (standardFormat)
		89		{
		90		case (default):
		91		case 'g':
		92		case 'G':
		93		case 'd':
		94		case 'D':
	1	95		return TryParseInt16D(text, out value, out bytesConsumed);
		96
		97		case 'n':
		98		case 'N':
	1	99		return TryParseInt16N(text, out value, out bytesConsumed);
		100
		101		case 'x':
		102		case 'X':
	1	103		value = default;
	1	104		return TryParseUInt16X(text, out Unsafe.As<short, ushort>(ref value), out bytesConsumed);
		105
		106		default:
	1	107		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		108		}
	1	109		}
		110
		111		/// <summary>
		112		/// Parses an Int32 at the start of a Utf8 string.
		113		/// </summary>
		114		/// <param name="text">The Utf8 string to parse</param>
		115		/// <param name="value">Receives the parsed value</param>
		116		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		117		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		118		/// <returns>
		119		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		120		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		121		/// </returns>
		122		/// <remarks>
		123		/// Formats supported:
		124		///     G/g (default)
		125		///     D/d             32767
		126		///     N/n             32,767
		127		///     X/x             7fff
		128		/// </remarks>
		129		/// <exceptions>
		130		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		131		/// </exceptions>
		132		public static bool TryParse(ReadOnlySpan<byte> text, out int value, out int bytesConsumed, char standardFormat =
	1	133		{
	1	134		switch (standardFormat)
		135		{
		136		case (default):
		137		case 'g':
		138		case 'G':
		139		case 'd':
		140		case 'D':
	1	141		return TryParseInt32D(text, out value, out bytesConsumed);
		142
		143		case 'n':
		144		case 'N':
	1	145		return TryParseInt32N(text, out value, out bytesConsumed);
		146
		147		case 'x':
		148		case 'X':
	1	149		value = default;
	1	150		return TryParseUInt32X(text, out Unsafe.As<int, uint>(ref value), out bytesConsumed);
		151
		152		default:
	1	153		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		154		}
	1	155		}
		156
		157		/// <summary>
		158		/// Parses an Int64 at the start of a Utf8 string.
		159		/// </summary>
		160		/// <param name="text">The Utf8 string to parse</param>
		161		/// <param name="value">Receives the parsed value</param>
		162		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		163		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		164		/// <returns>
		165		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		166		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		167		/// </returns>
		168		/// <remarks>
		169		/// Formats supported:
		170		///     G/g (default)
		171		///     D/d             32767
		172		///     N/n             32,767
		173		///     X/x             7fff
		174		/// </remarks>
		175		/// <exceptions>
		176		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		177		/// </exceptions>
		178		public static bool TryParse(ReadOnlySpan<byte> text, out long value, out int bytesConsumed, char standardFormat
	1	179		{
	1	180		switch (standardFormat)
		181		{
		182		case (default):
		183		case 'g':
		184		case 'G':
		185		case 'd':
		186		case 'D':
	1	187		return TryParseInt64D(text, out value, out bytesConsumed);
		188
		189		case 'n':
		190		case 'N':
	1	191		return TryParseInt64N(text, out value, out bytesConsumed);
		192
		193		case 'x':
		194		case 'X':
	1	195		value = default;
	1	196		return TryParseUInt64X(text, out Unsafe.As<long, ulong>(ref value), out bytesConsumed);
		197
		198		default:
	1	199		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		200		}
	1	201		}
		202		}
		203		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.D.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseSByteD(ReadOnlySpan<byte> text, out sbyte value, out int bytesConsumed)
	1	10		{
	1	11		if (text.Length < 1)
	1	12		goto FalseExit;
		13
	1	14		int sign = 1;
	1	15		int index = 0;
	1	16		int num = text[index];
	1	17		if (num == '-')
	1	18		{
	1	19		sign = -1;
	1	20		index++;
	1	21		if ((uint)index >= (uint)text.Length)
	1	22		goto FalseExit;
	1	23		num = text[index];
	1	24		}
	1	25		else if (num == '+')
	1	26		{
	1	27		index++;
	1	28		if ((uint)index >= (uint)text.Length)
	1	29		goto FalseExit;
	1	30		num = text[index];
	1	31		}
		32
	1	33		int answer = 0;
		34
	1	35		if (ParserHelpers.IsDigit(num))
	1	36		{
	1	37		if (num == '0')
	1	38		{
		39		do
	1	40		{
	1	41		index++;
	1	42		if ((uint)index >= (uint)text.Length)
	1	43		goto Done;
	1	44		num = text[index];
	2	45		} while (num == '0');
	1	46		if (!ParserHelpers.IsDigit(num))
	1	47		goto Done;
	1	48		}
		49
	1	50		answer = num - '0';
	1	51		index++;
		52
	1	53		if ((uint)index >= (uint)text.Length)
	1	54		goto Done;
	1	55		num = text[index];
	1	56		if (!ParserHelpers.IsDigit(num))
	1	57		goto Done;
	1	58		index++;
	1	59		answer = 10 * answer + num - '0';
		60
		61		// Potential overflow
	1	62		if ((uint)index >= (uint)text.Length)
	1	63		goto Done;
	1	64		num = text[index];
	1	65		if (!ParserHelpers.IsDigit(num))
	1	66		goto Done;
	1	67		index++;
	1	68		answer = answer * 10 + num - '0';
		69		// if sign < 0, (-1 * sign + 1) / 2 = 1
		70		// else, (-1 * sign + 1) / 2 = 0
	1	71		if ((uint)answer > (uint)sbyte.MaxValue + (-1 * sign + 1) / 2)
	1	72		goto FalseExit; // Overflow
		73
	1	74		if ((uint)index >= (uint)text.Length)
	1	75		goto Done;
	1	76		if (!ParserHelpers.IsDigit(text[index]))
	1	77		goto Done;
		78
		79		// Guaranteed overflow
	1	80		goto FalseExit;
		81		}
		82
	1	83		FalseExit:
	1	84		bytesConsumed = default;
	1	85		value = default;
	1	86		return false;
		87
	1	88		Done:
	1	89		bytesConsumed = index;
	1	90		value = (sbyte)(answer * sign);
	1	91		return true;
	1	92		}
		93
		94		private static bool TryParseInt16D(ReadOnlySpan<byte> text, out short value, out int bytesConsumed)
	1	95		{
	1	96		if (text.Length < 1)
	1	97		goto FalseExit;
		98
	1	99		int sign = 1;
	1	100		int index = 0;
	1	101		int num = text[index];
	1	102		if (num == '-')
	1	103		{
	1	104		sign = -1;
	1	105		index++;
	1	106		if ((uint)index >= (uint)text.Length)
	1	107		goto FalseExit;
	1	108		num = text[index];
	1	109		}
	1	110		else if (num == '+')
	1	111		{
	1	112		index++;
	1	113		if ((uint)index >= (uint)text.Length)
	1	114		goto FalseExit;
	1	115		num = text[index];
	1	116		}
		117
	1	118		int answer = 0;
		119
	1	120		if (ParserHelpers.IsDigit(num))
	1	121		{
	1	122		if (num == '0')
	1	123		{
		124		do
	1	125		{
	1	126		index++;
	1	127		if ((uint)index >= (uint)text.Length)
	1	128		goto Done;
	1	129		num = text[index];
	2	130		} while (num == '0');
	1	131		if (!ParserHelpers.IsDigit(num))
	1	132		goto Done;
	1	133		}
		134
	1	135		answer = num - '0';
	1	136		index++;
		137
	1	138		if ((uint)index >= (uint)text.Length)
	1	139		goto Done;
	1	140		num = text[index];
	1	141		if (!ParserHelpers.IsDigit(num))
	1	142		goto Done;
	1	143		index++;
	1	144		answer = 10 * answer + num - '0';
		145
	1	146		if ((uint)index >= (uint)text.Length)
	1	147		goto Done;
	1	148		num = text[index];
	1	149		if (!ParserHelpers.IsDigit(num))
	1	150		goto Done;
	1	151		index++;
	1	152		answer = 10 * answer + num - '0';
		153
	1	154		if ((uint)index >= (uint)text.Length)
	1	155		goto Done;
	1	156		num = text[index];
	1	157		if (!ParserHelpers.IsDigit(num))
	1	158		goto Done;
	1	159		index++;
	1	160		answer = 10 * answer + num - '0';
		161
		162		// Potential overflow
	1	163		if ((uint)index >= (uint)text.Length)
	1	164		goto Done;
	1	165		num = text[index];
	1	166		if (!ParserHelpers.IsDigit(num))
	1	167		goto Done;
	1	168		index++;
	1	169		answer = answer * 10 + num - '0';
		170		// if sign < 0, (-1 * sign + 1) / 2 = 1
		171		// else, (-1 * sign + 1) / 2 = 0
	1	172		if ((uint)answer > (uint)short.MaxValue + (-1 * sign + 1) / 2)
	1	173		goto FalseExit; // Overflow
		174
	1	175		if ((uint)index >= (uint)text.Length)
	1	176		goto Done;
	1	177		if (!ParserHelpers.IsDigit(text[index]))
	1	178		goto Done;
		179
		180		// Guaranteed overflow
	1	181		goto FalseExit;
		182		}
		183
	1	184		FalseExit:
	1	185		bytesConsumed = default;
	1	186		value = default;
	1	187		return false;
		188
	1	189		Done:
	1	190		bytesConsumed = index;
	1	191		value = (short)(answer * sign);
	1	192		return true;
	1	193		}
		194
		195		private static bool TryParseInt32D(ReadOnlySpan<byte> text, out int value, out int bytesConsumed)
	1	196		{
	1	197		if (text.Length < 1)
	1	198		goto FalseExit;
		199
	1	200		int sign = 1;
	1	201		int index = 0;
	1	202		int num = text[index];
	1	203		if (num == '-')
	1	204		{
	1	205		sign = -1;
	1	206		index++;
	1	207		if ((uint)index >= (uint)text.Length)
	1	208		goto FalseExit;
	1	209		num = text[index];
	1	210		}
	1	211		else if (num == '+')
	1	212		{
	1	213		index++;
	1	214		if ((uint)index >= (uint)text.Length)
	1	215		goto FalseExit;
	1	216		num = text[index];
	1	217		}
		218
	1	219		int answer = 0;
		220
	1	221		if (ParserHelpers.IsDigit(num))
	1	222		{
	1	223		if (num == '0')
	1	224		{
		225		do
	1	226		{
	1	227		index++;
	1	228		if ((uint)index >= (uint)text.Length)
	1	229		goto Done;
	1	230		num = text[index];
	2	231		} while (num == '0');
	1	232		if (!ParserHelpers.IsDigit(num))
	1	233		goto Done;
	1	234		}
		235
	1	236		answer = num - '0';
	1	237		index++;
		238
	1	239		if ((uint)index >= (uint)text.Length)
	1	240		goto Done;
	1	241		num = text[index];
	1	242		if (!ParserHelpers.IsDigit(num))
	1	243		goto Done;
	1	244		index++;
	1	245		answer = 10 * answer + num - '0';
		246
	1	247		if ((uint)index >= (uint)text.Length)
	1	248		goto Done;
	1	249		num = text[index];
	1	250		if (!ParserHelpers.IsDigit(num))
	1	251		goto Done;
	1	252		index++;
	1	253		answer = 10 * answer + num - '0';
		254
	1	255		if ((uint)index >= (uint)text.Length)
	1	256		goto Done;
	1	257		num = text[index];
	1	258		if (!ParserHelpers.IsDigit(num))
	1	259		goto Done;
	1	260		index++;
	1	261		answer = 10 * answer + num - '0';
		262
	1	263		if ((uint)index >= (uint)text.Length)
	1	264		goto Done;
	1	265		num = text[index];
	1	266		if (!ParserHelpers.IsDigit(num))
	1	267		goto Done;
	1	268		index++;
	1	269		answer = 10 * answer + num - '0';
		270
	1	271		if ((uint)index >= (uint)text.Length)
	1	272		goto Done;
	1	273		num = text[index];
	1	274		if (!ParserHelpers.IsDigit(num))
	1	275		goto Done;
	1	276		index++;
	1	277		answer = 10 * answer + num - '0';
		278
	1	279		if ((uint)index >= (uint)text.Length)
	1	280		goto Done;
	1	281		num = text[index];
	1	282		if (!ParserHelpers.IsDigit(num))
	1	283		goto Done;
	1	284		index++;
	1	285		answer = 10 * answer + num - '0';
		286
	1	287		if ((uint)index >= (uint)text.Length)
	1	288		goto Done;
	1	289		num = text[index];
	1	290		if (!ParserHelpers.IsDigit(num))
	1	291		goto Done;
	1	292		index++;
	1	293		answer = 10 * answer + num - '0';
		294
	1	295		if ((uint)index >= (uint)text.Length)
	1	296		goto Done;
	1	297		num = text[index];
	1	298		if (!ParserHelpers.IsDigit(num))
	1	299		goto Done;
	1	300		index++;
	1	301		answer = 10 * answer + num - '0';
		302
		303		// Potential overflow
	1	304		if ((uint)index >= (uint)text.Length)
	1	305		goto Done;
	1	306		num = text[index];
	1	307		if (!ParserHelpers.IsDigit(num))
	1	308		goto Done;
	1	309		index++;
	1	310		if (answer > int.MaxValue / 10)
	1	311		goto FalseExit; // Overflow
	1	312		answer = answer * 10 + num - '0';
		313		// if sign < 0, (-1 * sign + 1) / 2 = 1
		314		// else, (-1 * sign + 1) / 2 = 0
	1	315		if ((uint)answer > (uint)int.MaxValue + (-1 * sign + 1) / 2)
	1	316		goto FalseExit; // Overflow
		317
	1	318		if ((uint)index >= (uint)text.Length)
	1	319		goto Done;
	1	320		if (!ParserHelpers.IsDigit(text[index]))
	1	321		goto Done;
		322
		323		// Guaranteed overflow
	1	324		goto FalseExit;
		325		}
		326
	1	327		FalseExit:
	1	328		bytesConsumed = default;
	1	329		value = default;
	1	330		return false;
		331
	1	332		Done:
	1	333		bytesConsumed = index;
	1	334		value = answer * sign;
	1	335		return true;
	1	336		}
		337
		338		private static bool TryParseInt64D(ReadOnlySpan<byte> text, out long value, out int bytesConsumed)
	1	339		{
	1	340		if (text.Length < 1)
	1	341		{
	1	342		bytesConsumed = 0;
	1	343		value = default;
	1	344		return false;
		345		}
		346
	1	347		int indexOfFirstDigit = 0;
	1	348		int sign = 1;
	1	349		if (text[0] == '-')
	1	350		{
	1	351		indexOfFirstDigit = 1;
	1	352		sign = -1;
		353
	1	354		if (text.Length <= indexOfFirstDigit)
	1	355		{
	1	356		bytesConsumed = 0;
	1	357		value = default;
	1	358		return false;
		359		}
	1	360		}
	1	361		else if (text[0] == '+')
	1	362		{
	1	363		indexOfFirstDigit = 1;
		364
	1	365		if (text.Length <= indexOfFirstDigit)
	1	366		{
	1	367		bytesConsumed = 0;
	1	368		value = default;
	1	369		return false;
		370		}
	1	371		}
		372
	1	373		int overflowLength = ParserHelpers.Int64OverflowLength + indexOfFirstDigit;
		374
		375		// Parse the first digit separately. If invalid here, we need to return false.
	1	376		long firstDigit = text[indexOfFirstDigit] - 48; // '0'
	1	377		if (firstDigit < 0 || firstDigit > 9)
	1	378		{
	1	379		bytesConsumed = 0;
	1	380		value = default;
	1	381		return false;
		382		}
	1	383		ulong parsedValue = (ulong)firstDigit;
		384
	1	385		if (text.Length < overflowLength)
	1	386		{
		387		// Length is less than Parsers.Int64OverflowLength; overflow is not possible
	3	388		for (int index = indexOfFirstDigit + 1; index < text.Length; index++)
	1	389		{
	1	390		long nextDigit = text[index] - 48; // '0'
	1	391		if (nextDigit < 0 || nextDigit > 9)
	1	392		{
	1	393		bytesConsumed = index;
	1	394		value = ((long)parsedValue) * sign;
	1	395		return true;
		396		}
	1	397		parsedValue = parsedValue * 10 + (ulong)nextDigit;
	1	398		}
	1	399		}
		400		else
	1	401		{
		402		// Length is greater than Parsers.Int64OverflowLength; overflow is only possible after Parsers.Int64Over
		403		// digits. There may be no overflow after Parsers.Int64OverflowLength if there are leading zeroes.
	3	404		for (int index = indexOfFirstDigit + 1; index < overflowLength - 1; index++)
	1	405		{
	1	406		long nextDigit = text[index] - 48; // '0'
	1	407		if (nextDigit < 0 || nextDigit > 9)
	1	408		{
	1	409		bytesConsumed = index;
	1	410		value = ((long)parsedValue) * sign;
	1	411		return true;
		412		}
	1	413		parsedValue = parsedValue * 10 + (ulong)nextDigit;
	1	414		}
	3	415		for (int index = overflowLength - 1; index < text.Length; index++)
	1	416		{
	1	417		long nextDigit = text[index] - 48; // '0'
	1	418		if (nextDigit < 0 || nextDigit > 9)
	1	419		{
	1	420		bytesConsumed = index;
	1	421		value = ((long)parsedValue) * sign;
	1	422		return true;
		423		}
		424		// If parsedValue > (long.MaxValue / 10), any more appended digits will cause overflow.
		425		// if parsedValue == (long.MaxValue / 10), any nextDigit greater than 7 or 8 (depending on sign) imp
	1	426		bool positive = sign > 0;
	1	427		bool nextDigitTooLarge = nextDigit > 8 || (positive && nextDigit > 7);
	1	428		if (parsedValue > long.MaxValue / 10 || parsedValue == long.MaxValue / 10 && nextDigitTooLarge)
	1	429		{
	1	430		bytesConsumed = 0;
	1	431		value = default;
	1	432		return false;
		433		}
	1	434		parsedValue = parsedValue * 10 + (ulong)nextDigit;
	1	435		}
	1	436		}
		437
	1	438		bytesConsumed = text.Length;
	1	439		value = ((long)parsedValue) * sign;
	1	440		return true;
	1	441		}
		442		}
		443		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.N.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseSByteN(ReadOnlySpan<byte> text, out sbyte value, out int bytesConsumed)
	1	10		{
	1	11		if (text.Length < 1)
	1	12		goto FalseExit;
		13
	1	14		int sign = 1;
	1	15		int index = 0;
	1	16		int c = text[index];
	1	17		if (c == '-')
	1	18		{
	1	19		sign = -1;
	1	20		index++;
	1	21		if ((uint)index >= (uint)text.Length)
	1	22		goto FalseExit;
	1	23		c = text[index];
	1	24		}
	1	25		else if (c == '+')
	1	26		{
	1	27		index++;
	1	28		if ((uint)index >= (uint)text.Length)
	1	29		goto FalseExit;
	1	30		c = text[index];
	1	31		}
		32
		33		int answer;
		34
		35		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		36		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		37		// one digit after the decimal point.)
	1	38		if (c == Utf8Constants.Period)
	1	39		goto FractionalPartWithoutLeadingDigits;
	1	40		if (!ParserHelpers.IsDigit(c))
	1	41		goto FalseExit;
	1	42		answer = c - '0';
		43
		44		for (; ; )
	1	45		{
	1	46		index++;
	1	47		if ((uint)index >= (uint)text.Length)
	1	48		goto Done;
		49
	1	50		c = text[index];
	1	51		if (c == Utf8Constants.Comma)
	1	52		continue;
		53
	1	54		if (c == Utf8Constants.Period)
	1	55		goto FractionalDigits;
		56
	1	57		if (!ParserHelpers.IsDigit(c))
	1	58		goto Done;
		59
	1	60		answer = answer * 10 + c - '0';
		61
		62		// if sign < 0, (-1 * sign + 1) / 2 = 1
		63		// else, (-1 * sign + 1) / 2 = 0
	1	64		if (answer > sbyte.MaxValue + (-1 * sign + 1) / 2)
	1	65		goto FalseExit; // Overflow
	1	66		}
		67
	1	68		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	69		answer = 0;
	1	70		index++;
	1	71		if ((uint)index >= (uint)text.Length)
	1	72		goto FalseExit;
	1	73		if (text[index] != '0')
	1	74		goto FalseExit;
		75
	1	76		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		77		do
	1	78		{
	1	79		index++;
	1	80		if ((uint)index >= (uint)text.Length)
	1	81		goto Done;
	1	82		c = text[index];
	1	83		}
	1	84		while (c == '0');
		85
	1	86		if (ParserHelpers.IsDigit(c))
	1	87		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	88		goto Done;
		89
	1	90		FalseExit:
	1	91		bytesConsumed = default;
	1	92		value = default;
	1	93		return false;
		94
	1	95		Done:
	1	96		bytesConsumed = index;
	1	97		value = (sbyte)(answer * sign);
	1	98		return true;
	1	99		}
		100
		101		private static bool TryParseInt16N(ReadOnlySpan<byte> text, out short value, out int bytesConsumed)
	1	102		{
	1	103		if (text.Length < 1)
	1	104		goto FalseExit;
		105
	1	106		int sign = 1;
	1	107		int index = 0;
	1	108		int c = text[index];
	1	109		if (c == '-')
	1	110		{
	1	111		sign = -1;
	1	112		index++;
	1	113		if ((uint)index >= (uint)text.Length)
	1	114		goto FalseExit;
	1	115		c = text[index];
	1	116		}
	1	117		else if (c == '+')
	1	118		{
	1	119		index++;
	1	120		if ((uint)index >= (uint)text.Length)
	1	121		goto FalseExit;
	1	122		c = text[index];
	1	123		}
		124
		125		int answer;
		126
		127		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		128		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		129		// one digit after the decimal point.)
	1	130		if (c == Utf8Constants.Period)
	1	131		goto FractionalPartWithoutLeadingDigits;
	1	132		if (!ParserHelpers.IsDigit(c))
	1	133		goto FalseExit;
	1	134		answer = c - '0';
		135
		136		for (; ; )
	1	137		{
	1	138		index++;
	1	139		if ((uint)index >= (uint)text.Length)
	1	140		goto Done;
		141
	1	142		c = text[index];
	1	143		if (c == Utf8Constants.Comma)
	1	144		continue;
		145
	1	146		if (c == Utf8Constants.Period)
	1	147		goto FractionalDigits;
		148
	1	149		if (!ParserHelpers.IsDigit(c))
	1	150		goto Done;
		151
	1	152		answer = answer * 10 + c - '0';
		153
		154		// if sign < 0, (-1 * sign + 1) / 2 = 1
		155		// else, (-1 * sign + 1) / 2 = 0
	1	156		if (answer > short.MaxValue + (-1 * sign + 1) / 2)
	1	157		goto FalseExit; // Overflow
	1	158		}
		159
	1	160		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	161		answer = 0;
	1	162		index++;
	1	163		if ((uint)index >= (uint)text.Length)
	1	164		goto FalseExit;
	1	165		if (text[index] != '0')
	1	166		goto FalseExit;
		167
	1	168		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		169		do
	1	170		{
	1	171		index++;
	1	172		if ((uint)index >= (uint)text.Length)
	1	173		goto Done;
	1	174		c = text[index];
	1	175		}
	1	176		while (c == '0');
		177
	1	178		if (ParserHelpers.IsDigit(c))
	1	179		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	180		goto Done;
		181
	1	182		FalseExit:
	1	183		bytesConsumed = default;
	1	184		value = default;
	1	185		return false;
		186
	1	187		Done:
	1	188		bytesConsumed = index;
	1	189		value = (short)(answer * sign);
	1	190		return true;
	1	191		}
		192
		193		private static bool TryParseInt32N(ReadOnlySpan<byte> text, out int value, out int bytesConsumed)
	1	194		{
	1	195		if (text.Length < 1)
	1	196		goto FalseExit;
		197
	1	198		int sign = 1;
	1	199		int index = 0;
	1	200		int c = text[index];
	1	201		if (c == '-')
	1	202		{
	1	203		sign = -1;
	1	204		index++;
	1	205		if ((uint)index >= (uint)text.Length)
	1	206		goto FalseExit;
	1	207		c = text[index];
	1	208		}
	1	209		else if (c == '+')
	1	210		{
	1	211		index++;
	1	212		if ((uint)index >= (uint)text.Length)
	1	213		goto FalseExit;
	1	214		c = text[index];
	1	215		}
		216
		217		int answer;
		218
		219		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		220		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		221		// one digit after the decimal point.)
	1	222		if (c == Utf8Constants.Period)
	1	223		goto FractionalPartWithoutLeadingDigits;
	1	224		if (!ParserHelpers.IsDigit(c))
	1	225		goto FalseExit;
	1	226		answer = c - '0';
		227
		228		for (; ; )
	1	229		{
	1	230		index++;
	1	231		if ((uint)index >= (uint)text.Length)
	1	232		goto Done;
		233
	1	234		c = text[index];
	1	235		if (c == Utf8Constants.Comma)
	1	236		continue;
		237
	1	238		if (c == Utf8Constants.Period)
	1	239		goto FractionalDigits;
		240
	1	241		if (!ParserHelpers.IsDigit(c))
	1	242		goto Done;
		243
	1	244		if (((uint)answer) > int.MaxValue / 10)
	1	245		goto FalseExit;
		246
	1	247		answer = answer * 10 + c - '0';
		248
		249		// if sign < 0, (-1 * sign + 1) / 2 = 1
		250		// else, (-1 * sign + 1) / 2 = 0
	1	251		if ((uint)answer > (uint)int.MaxValue + (-1 * sign + 1) / 2)
	1	252		goto FalseExit; // Overflow
	1	253		}
		254
	1	255		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	256		answer = 0;
	1	257		index++;
	1	258		if ((uint)index >= (uint)text.Length)
	1	259		goto FalseExit;
	1	260		if (text[index] != '0')
	1	261		goto FalseExit;
		262
	1	263		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		264		do
	1	265		{
	1	266		index++;
	1	267		if ((uint)index >= (uint)text.Length)
	1	268		goto Done;
	1	269		c = text[index];
	1	270		}
	1	271		while (c == '0');
		272
	1	273		if (ParserHelpers.IsDigit(c))
	1	274		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	275		goto Done;
		276
	1	277		FalseExit:
	1	278		bytesConsumed = default;
	1	279		value = default;
	1	280		return false;
		281
	1	282		Done:
	1	283		bytesConsumed = index;
	1	284		value = answer * sign;
	1	285		return true;
	1	286		}
		287
		288		private static bool TryParseInt64N(ReadOnlySpan<byte> text, out long value, out int bytesConsumed)
	1	289		{
	1	290		if (text.Length < 1)
	1	291		goto FalseExit;
		292
	1	293		int sign = 1;
	1	294		int index = 0;
	1	295		int c = text[index];
	1	296		if (c == '-')
	1	297		{
	1	298		sign = -1;
	1	299		index++;
	1	300		if ((uint)index >= (uint)text.Length)
	1	301		goto FalseExit;
	1	302		c = text[index];
	1	303		}
	1	304		else if (c == '+')
	1	305		{
	1	306		index++;
	1	307		if ((uint)index >= (uint)text.Length)
	1	308		goto FalseExit;
	1	309		c = text[index];
	1	310		}
		311
		312		long answer;
		313
		314		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		315		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		316		// one digit after the decimal point.)
	1	317		if (c == Utf8Constants.Period)
	1	318		goto FractionalPartWithoutLeadingDigits;
	1	319		if (!ParserHelpers.IsDigit(c))
	1	320		goto FalseExit;
	1	321		answer = c - '0';
		322
		323		for (; ; )
	1	324		{
	1	325		index++;
	1	326		if ((uint)index >= (uint)text.Length)
	1	327		goto Done;
		328
	1	329		c = text[index];
	1	330		if (c == Utf8Constants.Comma)
	1	331		continue;
		332
	1	333		if (c == Utf8Constants.Period)
	1	334		goto FractionalDigits;
		335
	1	336		if (!ParserHelpers.IsDigit(c))
	1	337		goto Done;
		338
	1	339		if (((ulong)answer) > long.MaxValue / 10)
	1	340		goto FalseExit;
		341
	1	342		answer = answer * 10 + c - '0';
		343
		344		// if sign < 0, (-1 * sign + 1) / 2 = 1
		345		// else, (-1 * sign + 1) / 2 = 0
	1	346		if ((ulong)answer > (ulong)(long.MaxValue + (-1 * sign + 1) / 2))
	1	347		goto FalseExit; // Overflow
	1	348		}
		349
	1	350		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	351		answer = 0;
	1	352		index++;
	1	353		if ((uint)index >= (uint)text.Length)
	1	354		goto FalseExit;
	1	355		if (text[index] != '0')
	1	356		goto FalseExit;
		357
	1	358		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		359		do
	1	360		{
	1	361		index++;
	1	362		if ((uint)index >= (uint)text.Length)
	1	363		goto Done;
	1	364		c = text[index];
	1	365		}
	1	366		while (c == '0');
		367
	1	368		if (ParserHelpers.IsDigit(c))
	1	369		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	370		goto Done;
		371
	1	372		FalseExit:
	1	373		bytesConsumed = default;
	1	374		value = default;
	1	375		return false;
		376
	1	377		Done:
	1	378		bytesConsumed = index;
	1	379		value = answer * sign;
	1	380		return true;
	1	381		}
		382		}
		383		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		/// <summary>
		10		/// Parses a Byte at the start of a Utf8 string.
		11		/// </summary>
		12		/// <param name="text">The Utf8 string to parse</param>
		13		/// <param name="value">Receives the parsed value</param>
		14		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		15		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		16		/// <returns>
		17		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		18		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		19		/// </returns>
		20		/// <remarks>
		21		/// Formats supported:
		22		///     G/g (default)
		23		///     D/d             32767
		24		///     N/n             32,767
		25		///     X/x             7fff
		26		/// </remarks>
		27		/// <exceptions>
		28		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		29		/// </exceptions>
		30		public static bool TryParse(ReadOnlySpan<byte> text, out byte value, out int bytesConsumed, char standardFormat
	1	31		{
	1	32		switch (standardFormat)
		33		{
		34		case (default):
		35		case 'g':
		36		case 'G':
		37		case 'd':
		38		case 'D':
	1	39		return TryParseByteD(text, out value, out bytesConsumed);
		40
		41		case 'n':
		42		case 'N':
	1	43		return TryParseByteN(text, out value, out bytesConsumed);
		44
		45		case 'x':
		46		case 'X':
	1	47		return TryParseByteX(text, out value, out bytesConsumed);
		48
		49		default:
	1	50		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		51		}
	1	52		}
		53
		54		/// <summary>
		55		/// Parses a UInt16 at the start of a Utf8 string.
		56		/// </summary>
		57		/// <param name="text">The Utf8 string to parse</param>
		58		/// <param name="value">Receives the parsed value</param>
		59		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		60		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		61		/// <returns>
		62		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		63		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		64		/// </returns>
		65		/// <remarks>
		66		/// Formats supported:
		67		///     G/g (default)
		68		///     D/d             32767
		69		///     N/n             32,767
		70		///     X/x             7fff
		71		/// </remarks>
		72		/// <exceptions>
		73		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		74		/// </exceptions>
		75		[CLSCompliant(false)]
		76		public static bool TryParse(ReadOnlySpan<byte> text, out ushort value, out int bytesConsumed, char standardForma
	1	77		{
	1	78		switch (standardFormat)
		79		{
		80		case (default):
		81		case 'g':
		82		case 'G':
		83		case 'd':
		84		case 'D':
	1	85		return TryParseUInt16D(text, out value, out bytesConsumed);
		86
		87		case 'n':
		88		case 'N':
	1	89		return TryParseUInt16N(text, out value, out bytesConsumed);
		90
		91		case 'x':
		92		case 'X':
	1	93		return TryParseUInt16X(text, out value, out bytesConsumed);
		94
		95		default:
	1	96		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		97		}
	1	98		}
		99
		100		/// <summary>
		101		/// Parses a UInt32 at the start of a Utf8 string.
		102		/// </summary>
		103		/// <param name="text">The Utf8 string to parse</param>
		104		/// <param name="value">Receives the parsed value</param>
		105		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		106		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		107		/// <returns>
		108		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		109		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		110		/// </returns>
		111		/// <remarks>
		112		/// Formats supported:
		113		///     G/g (default)
		114		///     D/d             32767
		115		///     N/n             32,767
		116		///     X/x             7fff
		117		/// </remarks>
		118		/// <exceptions>
		119		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		120		/// </exceptions>
		121		[CLSCompliant(false)]
		122		public static bool TryParse(ReadOnlySpan<byte> text, out uint value, out int bytesConsumed, char standardFormat
	1	123		{
	1	124		switch (standardFormat)
		125		{
		126		case (default):
		127		case 'g':
		128		case 'G':
		129		case 'd':
		130		case 'D':
	1	131		return TryParseUInt32D(text, out value, out bytesConsumed);
		132
		133		case 'n':
		134		case 'N':
	1	135		return TryParseUInt32N(text, out value, out bytesConsumed);
		136
		137		case 'x':
		138		case 'X':
	1	139		return TryParseUInt32X(text, out value, out bytesConsumed);
		140
		141		default:
	1	142		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		143		}
	1	144		}
		145
		146		/// <summary>
		147		/// Parses a UInt64 at the start of a Utf8 string.
		148		/// </summary>
		149		/// <param name="text">The Utf8 string to parse</param>
		150		/// <param name="value">Receives the parsed value</param>
		151		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		152		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		153		/// <returns>
		154		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		155		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		156		/// </returns>
		157		/// <remarks>
		158		/// Formats supported:
		159		///     G/g (default)
		160		///     D/d             32767
		161		///     N/n             32,767
		162		///     X/x             7fff
		163		/// </remarks>
		164		/// <exceptions>
		165		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		166		/// </exceptions>
		167		[CLSCompliant(false)]
		168		public static bool TryParse(ReadOnlySpan<byte> text, out ulong value, out int bytesConsumed, char standardFormat
	1	169		{
	1	170		switch (standardFormat)
		171		{
		172		case (default):
		173		case 'g':
		174		case 'G':
		175		case 'd':
		176		case 'D':
	1	177		return TryParseUInt64D(text, out value, out bytesConsumed);
		178
		179		case 'n':
		180		case 'N':
	1	181		return TryParseUInt64N(text, out value, out bytesConsumed);
		182
		183		case 'x':
		184		case 'X':
	1	185		return TryParseUInt64X(text, out value, out bytesConsumed);
		186
		187		default:
	1	188		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		189		}
	1	190		}
		191		}
		192		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.D.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseByteD(ReadOnlySpan<byte> text, out byte value, out int bytesConsumed)
	1	10		{
	1	11		if (text.Length < 1)
	1	12		goto FalseExit;
		13
	1	14		int index = 0;
	1	15		int num = text[index];
	1	16		int answer = 0;
		17
	1	18		if (ParserHelpers.IsDigit(num))
	1	19		{
	1	20		if (num == '0')
	1	21		{
		22		do
	1	23		{
	1	24		index++;
	1	25		if ((uint)index >= (uint)text.Length)
	1	26		goto Done;
	1	27		num = text[index];
	2	28		} while (num == '0');
	1	29		if (!ParserHelpers.IsDigit(num))
	1	30		goto Done;
	1	31		}
		32
	1	33		answer = num - '0';
	1	34		index++;
		35
	1	36		if ((uint)index >= (uint)text.Length)
	1	37		goto Done;
	1	38		num = text[index];
	1	39		if (!ParserHelpers.IsDigit(num))
	1	40		goto Done;
	1	41		index++;
	1	42		answer = 10 * answer + num - '0';
		43
		44		// Potential overflow
	1	45		if ((uint)index >= (uint)text.Length)
	1	46		goto Done;
	1	47		num = text[index];
	1	48		if (!ParserHelpers.IsDigit(num))
	1	49		goto Done;
	1	50		index++;
	1	51		answer = answer * 10 + num - '0';
	1	52		if ((uint)answer > byte.MaxValue)
	1	53		goto FalseExit; // Overflow
		54
	1	55		if ((uint)index >= (uint)text.Length)
	1	56		goto Done;
	1	57		if (!ParserHelpers.IsDigit(text[index]))
	1	58		goto Done;
		59
		60		// Guaranteed overflow
	1	61		goto FalseExit;
		62		}
		63
	1	64		FalseExit:
	1	65		bytesConsumed = default;
	1	66		value = default;
	1	67		return false;
		68
	1	69		Done:
	1	70		bytesConsumed = index;
	1	71		value = (byte)answer;
	1	72		return true;
	1	73		}
		74
		75		private static bool TryParseUInt16D(ReadOnlySpan<byte> text, out ushort value, out int bytesConsumed)
	1	76		{
	1	77		if (text.Length < 1)
	1	78		goto FalseExit;
		79
	1	80		int index = 0;
	1	81		int num = text[index];
	1	82		int answer = 0;
		83
	1	84		if (ParserHelpers.IsDigit(num))
	1	85		{
	1	86		if (num == '0')
	1	87		{
		88		do
	1	89		{
	1	90		index++;
	1	91		if ((uint)index >= (uint)text.Length)
	1	92		goto Done;
	1	93		num = text[index];
	2	94		} while (num == '0');
	1	95		if (!ParserHelpers.IsDigit(num))
	1	96		goto Done;
	1	97		}
		98
	1	99		answer = num - '0';
	1	100		index++;
		101
	1	102		if ((uint)index >= (uint)text.Length)
	1	103		goto Done;
	1	104		num = text[index];
	1	105		if (!ParserHelpers.IsDigit(num))
	1	106		goto Done;
	1	107		index++;
	1	108		answer = 10 * answer + num - '0';
		109
	1	110		if ((uint)index >= (uint)text.Length)
	1	111		goto Done;
	1	112		num = text[index];
	1	113		if (!ParserHelpers.IsDigit(num))
	1	114		goto Done;
	1	115		index++;
	1	116		answer = 10 * answer + num - '0';
		117
	1	118		if ((uint)index >= (uint)text.Length)
	1	119		goto Done;
	1	120		num = text[index];
	1	121		if (!ParserHelpers.IsDigit(num))
	1	122		goto Done;
	1	123		index++;
	1	124		answer = 10 * answer + num - '0';
		125
		126		// Potential overflow
	1	127		if ((uint)index >= (uint)text.Length)
	1	128		goto Done;
	1	129		num = text[index];
	1	130		if (!ParserHelpers.IsDigit(num))
	1	131		goto Done;
	1	132		index++;
	1	133		answer = answer * 10 + num - '0';
	1	134		if ((uint)answer > ushort.MaxValue)
	1	135		goto FalseExit; // Overflow
		136
	1	137		if ((uint)index >= (uint)text.Length)
	1	138		goto Done;
	1	139		if (!ParserHelpers.IsDigit(text[index]))
	1	140		goto Done;
		141
		142		// Guaranteed overflow
	1	143		goto FalseExit;
		144		}
		145
	1	146		FalseExit:
	1	147		bytesConsumed = default;
	1	148		value = default;
	1	149		return false;
		150
	1	151		Done:
	1	152		bytesConsumed = index;
	1	153		value = (ushort)answer;
	1	154		return true;
	1	155		}
		156
		157		private static bool TryParseUInt32D(ReadOnlySpan<byte> text, out uint value, out int bytesConsumed)
	1	158		{
	1	159		if (text.Length < 1)
	1	160		goto FalseExit;
		161
	1	162		int index = 0;
	1	163		int num = text[index];
	1	164		int answer = 0;
		165
	1	166		if (ParserHelpers.IsDigit(num))
	1	167		{
	1	168		if (num == '0')
	1	169		{
		170		do
	1	171		{
	1	172		index++;
	1	173		if ((uint)index >= (uint)text.Length)
	1	174		goto Done;
	1	175		num = text[index];
	2	176		} while (num == '0');
	1	177		if (!ParserHelpers.IsDigit(num))
	1	178		goto Done;
	1	179		}
		180
	1	181		answer = num - '0';
	1	182		index++;
		183
	1	184		if ((uint)index >= (uint)text.Length)
	1	185		goto Done;
	1	186		num = text[index];
	1	187		if (!ParserHelpers.IsDigit(num))
	1	188		goto Done;
	1	189		index++;
	1	190		answer = 10 * answer + num - '0';
		191
	1	192		if ((uint)index >= (uint)text.Length)
	1	193		goto Done;
	1	194		num = text[index];
	1	195		if (!ParserHelpers.IsDigit(num))
	1	196		goto Done;
	1	197		index++;
	1	198		answer = 10 * answer + num - '0';
		199
	1	200		if ((uint)index >= (uint)text.Length)
	1	201		goto Done;
	1	202		num = text[index];
	1	203		if (!ParserHelpers.IsDigit(num))
	1	204		goto Done;
	1	205		index++;
	1	206		answer = 10 * answer + num - '0';
		207
	1	208		if ((uint)index >= (uint)text.Length)
	1	209		goto Done;
	1	210		num = text[index];
	1	211		if (!ParserHelpers.IsDigit(num))
	1	212		goto Done;
	1	213		index++;
	1	214		answer = 10 * answer + num - '0';
		215
	1	216		if ((uint)index >= (uint)text.Length)
	1	217		goto Done;
	1	218		num = text[index];
	1	219		if (!ParserHelpers.IsDigit(num))
	1	220		goto Done;
	1	221		index++;
	1	222		answer = 10 * answer + num - '0';
		223
	1	224		if ((uint)index >= (uint)text.Length)
	1	225		goto Done;
	1	226		num = text[index];
	1	227		if (!ParserHelpers.IsDigit(num))
	1	228		goto Done;
	1	229		index++;
	1	230		answer = 10 * answer + num - '0';
		231
	1	232		if ((uint)index >= (uint)text.Length)
	1	233		goto Done;
	1	234		num = text[index];
	1	235		if (!ParserHelpers.IsDigit(num))
	1	236		goto Done;
	1	237		index++;
	1	238		answer = 10 * answer + num - '0';
		239
	1	240		if ((uint)index >= (uint)text.Length)
	1	241		goto Done;
	1	242		num = text[index];
	1	243		if (!ParserHelpers.IsDigit(num))
	1	244		goto Done;
	1	245		index++;
	1	246		answer = 10 * answer + num - '0';
		247
		248		// Potential overflow
	1	249		if ((uint)index >= (uint)text.Length)
	1	250		goto Done;
	1	251		num = text[index];
	1	252		if (!ParserHelpers.IsDigit(num))
	1	253		goto Done;
	1	254		index++;
	1	255		if (((uint)answer) > uint.MaxValue / 10 || (((uint)answer) == uint.MaxValue / 10 && num > '5'))
	1	256		goto FalseExit; // Overflow
	1	257		answer = answer * 10 + num - '0';
		258
	1	259		if ((uint)index >= (uint)text.Length)
	1	260		goto Done;
	1	261		if (!ParserHelpers.IsDigit(text[index]))
	1	262		goto Done;
		263
		264		// Guaranteed overflow
	1	265		goto FalseExit;
		266		}
		267
	1	268		FalseExit:
	1	269		bytesConsumed = default;
	1	270		value = default;
	1	271		return false;
		272
	1	273		Done:
	1	274		bytesConsumed = index;
	1	275		value = (uint)answer;
	1	276		return true;
	1	277		}
		278
		279		private static bool TryParseUInt64D(ReadOnlySpan<byte> text, out ulong value, out int bytesConsumed)
	1	280		{
	1	281		if (text.Length < 1)
	1	282		{
	1	283		bytesConsumed = 0;
	1	284		value = default;
	1	285		return false;
		286		}
		287
		288		// Parse the first digit separately. If invalid here, we need to return false.
	1	289		ulong firstDigit = text[0] - 48u; // '0'
	1	290		if (firstDigit > 9)
	1	291		{
	1	292		bytesConsumed = 0;
	1	293		value = default;
	1	294		return false;
		295		}
	1	296		ulong parsedValue = firstDigit;
		297
	1	298		if (text.Length < ParserHelpers.Int64OverflowLength)
	1	299		{
		300		// Length is less than Parsers.Int64OverflowLength; overflow is not possible
	3	301		for (int index = 1; index < text.Length; index++)
	1	302		{
	1	303		ulong nextDigit = text[index] - 48u; // '0'
	1	304		if (nextDigit > 9)
	1	305		{
	1	306		bytesConsumed = index;
	1	307		value = parsedValue;
	1	308		return true;
		309		}
	1	310		parsedValue = parsedValue * 10 + nextDigit;
	1	311		}
	1	312		}
		313		else
	1	314		{
		315		// Length is greater than Parsers.Int64OverflowLength; overflow is only possible after Parsers.Int64Over
		316		// digits. There may be no overflow after Parsers.Int64OverflowLength if there are leading zeroes.
	3	317		for (int index = 1; index < ParserHelpers.Int64OverflowLength - 1; index++)
	1	318		{
	1	319		ulong nextDigit = text[index] - 48u; // '0'
	1	320		if (nextDigit > 9)
	1	321		{
	1	322		bytesConsumed = index;
	1	323		value = parsedValue;
	1	324		return true;
		325		}
	1	326		parsedValue = parsedValue * 10 + nextDigit;
	1	327		}
	3	328		for (int index = ParserHelpers.Int64OverflowLength - 1; index < text.Length; index++)
	1	329		{
	1	330		ulong nextDigit = text[index] - 48u; // '0'
	1	331		if (nextDigit > 9)
	1	332		{
	1	333		bytesConsumed = index;
	1	334		value = parsedValue;
	1	335		return true;
		336		}
		337		// If parsedValue > (ulong.MaxValue / 10), any more appended digits will cause overflow.
		338		// if parsedValue == (ulong.MaxValue / 10), any nextDigit greater than 5 implies overflow.
	1	339		if (parsedValue > ulong.MaxValue / 10 || (parsedValue == ulong.MaxValue / 10 && nextDigit > 5))
	1	340		{
	1	341		bytesConsumed = 0;
	1	342		value = default;
	1	343		return false;
		344		}
	1	345		parsedValue = parsedValue * 10 + nextDigit;
	1	346		}
	1	347		}
		348
	1	349		bytesConsumed = text.Length;
	1	350		value = parsedValue;
	1	351		return true;
	1	352		}
		353		}
		354		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.N.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		//
		8		// Parsing unsigned integers for the 'N' format. Emulating int.TryParse(NumberStyles.AllowThousands | NumberStyles.I
		9		//
		10		public static partial class Utf8Parser
		11		{
		12		private static bool TryParseByteN(ReadOnlySpan<byte> text, out byte value, out int bytesConsumed)
	1	13		{
	1	14		if (text.Length < 1)
	1	15		goto FalseExit;
		16
	1	17		int index = 0;
	1	18		int c = text[index];
	1	19		if (c == '+')
	1	20		{
	1	21		index++;
	1	22		if ((uint)index >= (uint)text.Length)
	1	23		goto FalseExit;
	1	24		c = text[index];
	1	25		}
		26
		27		int answer;
		28
		29		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		30		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		31		// one digit after the decimal point.)
	1	32		if (c == Utf8Constants.Period)
	1	33		goto FractionalPartWithoutLeadingDigits;
	1	34		if (!ParserHelpers.IsDigit(c))
	1	35		goto FalseExit;
	1	36		answer = c - '0';
		37
		38		for (; ; )
	1	39		{
	1	40		index++;
	1	41		if ((uint)index >= (uint)text.Length)
	1	42		goto Done;
		43
	1	44		c = text[index];
	1	45		if (c == Utf8Constants.Comma)
	1	46		continue;
		47
	1	48		if (c == Utf8Constants.Period)
	1	49		goto FractionalDigits;
		50
	1	51		if (!ParserHelpers.IsDigit(c))
	1	52		goto Done;
		53
	1	54		answer = answer * 10 + c - '0';
		55
	1	56		if (answer > byte.MaxValue)
	1	57		goto FalseExit; // Overflow
	1	58		}
		59
	1	60		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	61		answer = 0;
	1	62		index++;
	1	63		if ((uint)index >= (uint)text.Length)
	1	64		goto FalseExit;
	1	65		if (text[index] != '0')
	1	66		goto FalseExit;
		67
	1	68		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		69		do
	1	70		{
	1	71		index++;
	1	72		if ((uint)index >= (uint)text.Length)
	1	73		goto Done;
	1	74		c = text[index];
	1	75		}
	1	76		while (c == '0');
		77
	1	78		if (ParserHelpers.IsDigit(c))
	1	79		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	80		goto Done;
		81
	1	82		FalseExit:
	1	83		bytesConsumed = default;
	1	84		value = default;
	1	85		return false;
		86
	1	87		Done:
	1	88		bytesConsumed = index;
	1	89		value = (byte)answer;
	1	90		return true;
	1	91		}
		92
		93		private static bool TryParseUInt16N(ReadOnlySpan<byte> text, out ushort value, out int bytesConsumed)
	1	94		{
	1	95		if (text.Length < 1)
	1	96		goto FalseExit;
		97
	1	98		int index = 0;
	1	99		int c = text[index];
	1	100		if (c == '+')
	1	101		{
	1	102		index++;
	1	103		if ((uint)index >= (uint)text.Length)
	1	104		goto FalseExit;
	1	105		c = text[index];
	1	106		}
		107
		108		int answer;
		109
		110		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		111		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		112		// one digit after the decimal point.)
	1	113		if (c == Utf8Constants.Period)
	1	114		goto FractionalPartWithoutLeadingDigits;
	1	115		if (!ParserHelpers.IsDigit(c))
	1	116		goto FalseExit;
	1	117		answer = c - '0';
		118
		119		for (; ; )
	1	120		{
	1	121		index++;
	1	122		if ((uint)index >= (uint)text.Length)
	1	123		goto Done;
		124
	1	125		c = text[index];
	1	126		if (c == Utf8Constants.Comma)
	1	127		continue;
		128
	1	129		if (c == Utf8Constants.Period)
	1	130		goto FractionalDigits;
		131
	1	132		if (!ParserHelpers.IsDigit(c))
	1	133		goto Done;
		134
	1	135		answer = answer * 10 + c - '0';
		136
	1	137		if (answer > ushort.MaxValue)
	1	138		goto FalseExit; // Overflow
	1	139		}
		140
	1	141		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	142		answer = 0;
	1	143		index++;
	1	144		if ((uint)index >= (uint)text.Length)
	1	145		goto FalseExit;
	1	146		if (text[index] != '0')
	1	147		goto FalseExit;
		148
	1	149		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		150		do
	1	151		{
	1	152		index++;
	1	153		if ((uint)index >= (uint)text.Length)
	1	154		goto Done;
	1	155		c = text[index];
	1	156		}
	1	157		while (c == '0');
		158
	1	159		if (ParserHelpers.IsDigit(c))
	1	160		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	161		goto Done;
		162
	1	163		FalseExit:
	1	164		bytesConsumed = default;
	1	165		value = default;
	1	166		return false;
		167
	1	168		Done:
	1	169		bytesConsumed = index;
	1	170		value = (ushort)answer;
	1	171		return true;
	1	172		}
		173
		174		private static bool TryParseUInt32N(ReadOnlySpan<byte> text, out uint value, out int bytesConsumed)
	1	175		{
	1	176		if (text.Length < 1)
	1	177		goto FalseExit;
		178
	1	179		int index = 0;
	1	180		int c = text[index];
	1	181		if (c == '+')
	1	182		{
	1	183		index++;
	1	184		if ((uint)index >= (uint)text.Length)
	1	185		goto FalseExit;
	1	186		c = text[index];
	1	187		}
		188
		189		int answer;
		190
		191		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		192		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		193		// one digit after the decimal point.)
	1	194		if (c == Utf8Constants.Period)
	1	195		goto FractionalPartWithoutLeadingDigits;
	1	196		if (!ParserHelpers.IsDigit(c))
	1	197		goto FalseExit;
	1	198		answer = c - '0';
		199
		200		for (; ; )
	1	201		{
	1	202		index++;
	1	203		if ((uint)index >= (uint)text.Length)
	1	204		goto Done;
		205
	1	206		c = text[index];
	1	207		if (c == Utf8Constants.Comma)
	1	208		continue;
		209
	1	210		if (c == Utf8Constants.Period)
	1	211		goto FractionalDigits;
		212
	1	213		if (!ParserHelpers.IsDigit(c))
	1	214		goto Done;
		215
	1	216		if (((uint)answer) > uint.MaxValue / 10 || (((uint)answer) == uint.MaxValue / 10 && c > '5'))
	1	217		goto FalseExit; // Overflow
		218
	1	219		answer = answer * 10 + c - '0';
	1	220		}
		221
	1	222		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	223		answer = 0;
	1	224		index++;
	1	225		if ((uint)index >= (uint)text.Length)
	1	226		goto FalseExit;
	1	227		if (text[index] != '0')
	1	228		goto FalseExit;
		229
	1	230		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		231		do
	1	232		{
	1	233		index++;
	1	234		if ((uint)index >= (uint)text.Length)
	1	235		goto Done;
	1	236		c = text[index];
	1	237		}
	1	238		while (c == '0');
		239
	1	240		if (ParserHelpers.IsDigit(c))
	1	241		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	242		goto Done;
		243
	1	244		FalseExit:
	1	245		bytesConsumed = default;
	1	246		value = default;
	1	247		return false;
		248
	1	249		Done:
	1	250		bytesConsumed = index;
	1	251		value = (uint)answer;
	1	252		return true;
	1	253		}
		254
		255		private static bool TryParseUInt64N(ReadOnlySpan<byte> text, out ulong value, out int bytesConsumed)
	1	256		{
	1	257		if (text.Length < 1)
	1	258		goto FalseExit;
		259
	1	260		int index = 0;
	1	261		int c = text[index];
	1	262		if (c == '+')
	1	263		{
	1	264		index++;
	1	265		if ((uint)index >= (uint)text.Length)
	1	266		goto FalseExit;
	1	267		c = text[index];
	1	268		}
		269
		270		long answer;
		271
		272		// Handle the first digit (or period) as a special case. This ensures some compatible edge-case behavior wit
		273		// (at least one digit must precede any commas, and a string without any digits prior to the decimal point m
		274		// one digit after the decimal point.)
	1	275		if (c == Utf8Constants.Period)
	1	276		goto FractionalPartWithoutLeadingDigits;
	1	277		if (!ParserHelpers.IsDigit(c))
	1	278		goto FalseExit;
	1	279		answer = c - '0';
		280
		281		for (; ; )
	1	282		{
	1	283		index++;
	1	284		if ((uint)index >= (uint)text.Length)
	1	285		goto Done;
		286
	1	287		c = text[index];
	1	288		if (c == Utf8Constants.Comma)
	1	289		continue;
		290
	1	291		if (c == Utf8Constants.Period)
	1	292		goto FractionalDigits;
		293
	1	294		if (!ParserHelpers.IsDigit(c))
	1	295		goto Done;
		296
	1	297		if (((ulong)answer) > ulong.MaxValue / 10 || (((ulong)answer) == ulong.MaxValue / 10 && c > '5'))
	1	298		goto FalseExit; // Overflow
		299
	1	300		answer = answer * 10 + c - '0';
	1	301		}
		302
	1	303		FractionalPartWithoutLeadingDigits: // If we got here, we found a decimal point before we found any digits. This is lega
	1	304		answer = 0;
	1	305		index++;
	1	306		if ((uint)index >= (uint)text.Length)
	1	307		goto FalseExit;
	1	308		if (text[index] != '0')
	1	309		goto FalseExit;
		310
	1	311		FractionalDigits: // "N" format allows a fractional portion despite being an integer format but only if the post-fractio
		312		do
	1	313		{
	1	314		index++;
	1	315		if ((uint)index >= (uint)text.Length)
	1	316		goto Done;
	1	317		c = text[index];
	1	318		}
	1	319		while (c == '0');
		320
	1	321		if (ParserHelpers.IsDigit(c))
	1	322		goto FalseExit; // The fractional portion contained a non-zero digit. Treat this as an error, not an ear
	1	323		goto Done;
		324
	1	325		FalseExit:
	1	326		bytesConsumed = default;
	1	327		value = default;
	1	328		return false;
		329
	1	330		Done:
	1	331		bytesConsumed = index;
	1	332		value = (ulong)answer;
	1	333		return true;
	1	334		}
		335		}
		336		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Unsigned.X.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseByteX(ReadOnlySpan<byte> text, out byte value, out int bytesConsumed)
	1	10		{
	1	11		if (text.Length < 1)
	1	12		{
	1	13		bytesConsumed = 0;
	1	14		value = default;
	1	15		return false;
		16		}
		17		byte nextCharacter;
		18		byte nextDigit;
		19
		20		// Cache Parsers.s_HexLookup in order to avoid static constructor checks
	1	21		byte[] hexLookup = ParserHelpers.s_hexLookup;
		22
		23		// Parse the first digit separately. If invalid here, we need to return false.
	1	24		nextCharacter = text[0];
	1	25		nextDigit = hexLookup[nextCharacter];
	1	26		if (nextDigit == 0xFF)
	1	27		{
	1	28		bytesConsumed = 0;
	1	29		value = default;
	1	30		return false;
		31		}
	1	32		uint parsedValue = nextDigit;
		33
	1	34		if (text.Length <= ParserHelpers.ByteOverflowLengthHex)
	1	35		{
		36		// Length is less than or equal to Parsers.ByteOverflowLengthHex; overflow is not possible
	3	37		for (int index = 1; index < text.Length; index++)
	1	38		{
	1	39		nextCharacter = text[index];
	1	40		nextDigit = hexLookup[nextCharacter];
	1	41		if (nextDigit == 0xFF)
	1	42		{
	1	43		bytesConsumed = index;
	1	44		value = (byte)(parsedValue);
	1	45		return true;
		46		}
	1	47		parsedValue = (parsedValue << 4) + nextDigit;
	1	48		}
	1	49		}
		50		else
	1	51		{
		52		// Length is greater than Parsers.ByteOverflowLengthHex; overflow is only possible after Parsers.ByteOve
		53		// digits. There may be no overflow after Parsers.ByteOverflowLengthHex if there are leading zeroes.
	3	54		for (int index = 1; index < ParserHelpers.ByteOverflowLengthHex; index++)
	1	55		{
	1	56		nextCharacter = text[index];
	1	57		nextDigit = hexLookup[nextCharacter];
	1	58		if (nextDigit == 0xFF)
	1	59		{
	1	60		bytesConsumed = index;
	1	61		value = (byte)(parsedValue);
	1	62		return true;
		63		}
	1	64		parsedValue = (parsedValue << 4) + nextDigit;
	1	65		}
	3	66		for (int index = ParserHelpers.ByteOverflowLengthHex; index < text.Length; index++)
	1	67		{
	1	68		nextCharacter = text[index];
	1	69		nextDigit = hexLookup[nextCharacter];
	1	70		if (nextDigit == 0xFF)
	1	71		{
	1	72		bytesConsumed = index;
	1	73		value = (byte)(parsedValue);
	1	74		return true;
		75		}
		76		// If we try to append a digit to anything larger than byte.MaxValue / 0x10, there will be overflow
	1	77		if (parsedValue > byte.MaxValue / 0x10)
	1	78		{
	1	79		bytesConsumed = 0;
	1	80		value = default;
	1	81		return false;
		82		}
	1	83		parsedValue = (parsedValue << 4) + nextDigit;
	1	84		}
	1	85		}
		86
	1	87		bytesConsumed = text.Length;
	1	88		value = (byte)(parsedValue);
	1	89		return true;
	1	90		}
		91
		92		private static bool TryParseUInt16X(ReadOnlySpan<byte> text, out ushort value, out int bytesConsumed)
	1	93		{
	1	94		if (text.Length < 1)
	1	95		{
	1	96		bytesConsumed = 0;
	1	97		value = default;
	1	98		return false;
		99		}
		100		byte nextCharacter;
		101		byte nextDigit;
		102
		103		// Cache Parsers.s_HexLookup in order to avoid static constructor checks
	1	104		byte[] hexLookup = ParserHelpers.s_hexLookup;
		105
		106		// Parse the first digit separately. If invalid here, we need to return false.
	1	107		nextCharacter = text[0];
	1	108		nextDigit = hexLookup[nextCharacter];
	1	109		if (nextDigit == 0xFF)
	1	110		{
	1	111		bytesConsumed = 0;
	1	112		value = default;
	1	113		return false;
		114		}
	1	115		uint parsedValue = nextDigit;
		116
	1	117		if (text.Length <= ParserHelpers.Int16OverflowLengthHex)
	1	118		{
		119		// Length is less than or equal to Parsers.Int16OverflowLengthHex; overflow is not possible
	3	120		for (int index = 1; index < text.Length; index++)
	1	121		{
	1	122		nextCharacter = text[index];
	1	123		nextDigit = hexLookup[nextCharacter];
	1	124		if (nextDigit == 0xFF)
	1	125		{
	1	126		bytesConsumed = index;
	1	127		value = (ushort)(parsedValue);
	1	128		return true;
		129		}
	1	130		parsedValue = (parsedValue << 4) + nextDigit;
	1	131		}
	1	132		}
		133		else
	1	134		{
		135		// Length is greater than Parsers.Int16OverflowLengthHex; overflow is only possible after Parsers.Int16O
		136		// digits. There may be no overflow after Parsers.Int16OverflowLengthHex if there are leading zeroes.
	3	137		for (int index = 1; index < ParserHelpers.Int16OverflowLengthHex; index++)
	1	138		{
	1	139		nextCharacter = text[index];
	1	140		nextDigit = hexLookup[nextCharacter];
	1	141		if (nextDigit == 0xFF)
	1	142		{
	1	143		bytesConsumed = index;
	1	144		value = (ushort)(parsedValue);
	1	145		return true;
		146		}
	1	147		parsedValue = (parsedValue << 4) + nextDigit;
	1	148		}
	3	149		for (int index = ParserHelpers.Int16OverflowLengthHex; index < text.Length; index++)
	1	150		{
	1	151		nextCharacter = text[index];
	1	152		nextDigit = hexLookup[nextCharacter];
	1	153		if (nextDigit == 0xFF)
	1	154		{
	1	155		bytesConsumed = index;
	1	156		value = (ushort)(parsedValue);
	1	157		return true;
		158		}
		159		// If we try to append a digit to anything larger than ushort.MaxValue / 0x10, there will be overflo
	1	160		if (parsedValue > ushort.MaxValue / 0x10)
	1	161		{
	1	162		bytesConsumed = 0;
	1	163		value = default;
	1	164		return false;
		165		}
	1	166		parsedValue = (parsedValue << 4) + nextDigit;
	1	167		}
	1	168		}
		169
	1	170		bytesConsumed = text.Length;
	1	171		value = (ushort)(parsedValue);
	1	172		return true;
	1	173		}
		174
		175		private static bool TryParseUInt32X(ReadOnlySpan<byte> text, out uint value, out int bytesConsumed)
	1	176		{
	1	177		if (text.Length < 1)
	1	178		{
	1	179		bytesConsumed = 0;
	1	180		value = default;
	1	181		return false;
		182		}
		183		byte nextCharacter;
		184		byte nextDigit;
		185
		186		// Cache Parsers.s_HexLookup in order to avoid static constructor checks
	1	187		byte[] hexLookup = ParserHelpers.s_hexLookup;
		188
		189		// Parse the first digit separately. If invalid here, we need to return false.
	1	190		nextCharacter = text[0];
	1	191		nextDigit = hexLookup[nextCharacter];
	1	192		if (nextDigit == 0xFF)
	1	193		{
	1	194		bytesConsumed = 0;
	1	195		value = default;
	1	196		return false;
		197		}
	1	198		uint parsedValue = nextDigit;
		199
	1	200		if (text.Length <= ParserHelpers.Int32OverflowLengthHex)
	1	201		{
		202		// Length is less than or equal to Parsers.Int32OverflowLengthHex; overflow is not possible
	3	203		for (int index = 1; index < text.Length; index++)
	1	204		{
	1	205		nextCharacter = text[index];
	1	206		nextDigit = hexLookup[nextCharacter];
	1	207		if (nextDigit == 0xFF)
	1	208		{
	1	209		bytesConsumed = index;
	1	210		value = parsedValue;
	1	211		return true;
		212		}
	1	213		parsedValue = (parsedValue << 4) + nextDigit;
	1	214		}
	1	215		}
		216		else
	1	217		{
		218		// Length is greater than Parsers.Int32OverflowLengthHex; overflow is only possible after Parsers.Int32O
		219		// digits. There may be no overflow after Parsers.Int32OverflowLengthHex if there are leading zeroes.
	3	220		for (int index = 1; index < ParserHelpers.Int32OverflowLengthHex; index++)
	1	221		{
	1	222		nextCharacter = text[index];
	1	223		nextDigit = hexLookup[nextCharacter];
	1	224		if (nextDigit == 0xFF)
	1	225		{
	1	226		bytesConsumed = index;
	1	227		value = parsedValue;
	1	228		return true;
		229		}
	1	230		parsedValue = (parsedValue << 4) + nextDigit;
	1	231		}
	3	232		for (int index = ParserHelpers.Int32OverflowLengthHex; index < text.Length; index++)
	1	233		{
	1	234		nextCharacter = text[index];
	1	235		nextDigit = hexLookup[nextCharacter];
	1	236		if (nextDigit == 0xFF)
	1	237		{
	1	238		bytesConsumed = index;
	1	239		value = parsedValue;
	1	240		return true;
		241		}
		242		// If we try to append a digit to anything larger than uint.MaxValue / 0x10, there will be overflow
	1	243		if (parsedValue > uint.MaxValue / 0x10)
	1	244		{
	1	245		bytesConsumed = 0;
	1	246		value = default;
	1	247		return false;
		248		}
	1	249		parsedValue = (parsedValue << 4) + nextDigit;
	1	250		}
	1	251		}
		252
	1	253		bytesConsumed = text.Length;
	1	254		value = parsedValue;
	1	255		return true;
	1	256		}
		257
		258		private static bool TryParseUInt64X(ReadOnlySpan<byte> text, out ulong value, out int bytesConsumed)
	1	259		{
	1	260		if (text.Length < 1)
	1	261		{
	1	262		bytesConsumed = 0;
	1	263		value = default;
	1	264		return false;
		265		}
		266		byte nextCharacter;
		267		byte nextDigit;
		268
		269		// Cache Parsers.s_HexLookup in order to avoid static constructor checks
	1	270		byte[] hexLookup = ParserHelpers.s_hexLookup;
		271
		272		// Parse the first digit separately. If invalid here, we need to return false.
	1	273		nextCharacter = text[0];
	1	274		nextDigit = hexLookup[nextCharacter];
	1	275		if (nextDigit == 0xFF)
	1	276		{
	1	277		bytesConsumed = 0;
	1	278		value = default;
	1	279		return false;
		280		}
	1	281		ulong parsedValue = nextDigit;
		282
	1	283		if (text.Length <= ParserHelpers.Int64OverflowLengthHex)
	1	284		{
		285		// Length is less than or equal to Parsers.Int64OverflowLengthHex; overflow is not possible
	3	286		for (int index = 1; index < text.Length; index++)
	1	287		{
	1	288		nextCharacter = text[index];
	1	289		nextDigit = hexLookup[nextCharacter];
	1	290		if (nextDigit == 0xFF)
	1	291		{
	1	292		bytesConsumed = index;
	1	293		value = parsedValue;
	1	294		return true;
		295		}
	1	296		parsedValue = (parsedValue << 4) + nextDigit;
	1	297		}
	1	298		}
		299		else
	1	300		{
		301		// Length is greater than Parsers.Int64OverflowLengthHex; overflow is only possible after Parsers.Int64O
		302		// digits. There may be no overflow after Parsers.Int64OverflowLengthHex if there are leading zeroes.
	3	303		for (int index = 1; index < ParserHelpers.Int64OverflowLengthHex; index++)
	1	304		{
	1	305		nextCharacter = text[index];
	1	306		nextDigit = hexLookup[nextCharacter];
	1	307		if (nextDigit == 0xFF)
	1	308		{
	1	309		bytesConsumed = index;
	1	310		value = parsedValue;
	1	311		return true;
		312		}
	1	313		parsedValue = (parsedValue << 4) + nextDigit;
	1	314		}
	3	315		for (int index = ParserHelpers.Int64OverflowLengthHex; index < text.Length; index++)
	1	316		{
	1	317		nextCharacter = text[index];
	1	318		nextDigit = hexLookup[nextCharacter];
	1	319		if (nextDigit == 0xFF)
	1	320		{
	1	321		bytesConsumed = index;
	1	322		value = parsedValue;
	1	323		return true;
		324		}
		325		// If we try to append a digit to anything larger than ulong.MaxValue / 0x10, there will be overflow
	1	326		if (parsedValue > ulong.MaxValue / 0x10)
	1	327		{
	1	328		bytesConsumed = 0;
	1	329		value = default;
	1	330		return false;
		331		}
	1	332		parsedValue = (parsedValue << 4) + nextDigit;
	1	333		}
	1	334		}
		335
	1	336		bytesConsumed = text.Length;
	1	337		value = parsedValue;
	1	338		return true;
	1	339		}
		340		}
		341		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Number.cs

	#	Line		Line coverage
		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> text, ref NumberBuffer number, out int bytesConsumed, Pars
	1	18		{
	1	19		Debug.Assert(number.Digits[0] == 0 && number.Scale == 0 && !number.IsNegative, "Number not initialized to de
		20
	1	21		textUsedExponentNotation = false;
		22
	1	23		if (text.Length == 0)
	1	24		{
	1	25		bytesConsumed = 0;
	1	26		return false;
		27		}
		28
	1	29		Span<byte> digits = number.Digits;
		30
	1	31		int srcIndex = 0;
	1	32		int dstIndex = 0;
		33
		34		// Consume the leading sign if any.
	1	35		byte c = text[srcIndex];
	1	36		switch (c)
		37		{
		38		case Utf8Constants.Minus:
	1	39		number.IsNegative = true;
	1	40		goto case Utf8Constants.Plus;
		41
		42		case Utf8Constants.Plus:
	1	43		srcIndex++;
	1	44		if (srcIndex == text.Length)
	1	45		{
	1	46		bytesConsumed = 0;
	1	47		return false;
		48		}
	1	49		c = text[srcIndex];
	1	50		break;
		51
		52		default:
	1	53		break;
		54		}
		55
	1	56		int startIndexDigitsBeforeDecimal = srcIndex;
		57
		58		// Throw away any leading zeroes
	1	59		while (srcIndex != text.Length)
	1	60		{
	1	61		c = text[srcIndex];
	1	62		if (c != '0')
	1	63		break;
	1	64		srcIndex++;
	1	65		}
		66
	1	67		if (srcIndex == text.Length)
	1	68		{
	1	69		digits[0] = 0;
	1	70		number.Scale = 0;
	1	71		bytesConsumed = srcIndex;
	1	72		number.CheckConsistency();
	1	73		return true;
		74		}
		75
	1	76		int startIndexNonLeadingDigitsBeforeDecimal = srcIndex;
	1	77		while (srcIndex != text.Length)
	1	78		{
	1	79		c = text[srcIndex];
	1	80		if ((c - 48u) > 9)
	1	81		break;
	1	82		srcIndex++;
	1	83		}
		84
	1	85		int numDigitsBeforeDecimal = srcIndex - startIndexDigitsBeforeDecimal;
	1	86		int numNonLeadingDigitsBeforeDecimal = srcIndex - startIndexNonLeadingDigitsBeforeDecimal;
		87
	1	88		Debug.Assert(dstIndex == 0);
	1	89		int numNonLeadingDigitsBeforeDecimalToCopy = Math.Min(numNonLeadingDigitsBeforeDecimal, NumberBuffer.BufferS
	1	90		text.Slice(startIndexNonLeadingDigitsBeforeDecimal, numNonLeadingDigitsBeforeDecimalToCopy).CopyTo(digits);
	1	91		dstIndex = numNonLeadingDigitsBeforeDecimalToCopy;
	1	92		number.Scale = numNonLeadingDigitsBeforeDecimal;
		93
	1	94		if (srcIndex == text.Length)
	1	95		{
	1	96		bytesConsumed = srcIndex;
	1	97		number.CheckConsistency();
	1	98		return true;
		99		}
		100
	1	101		int numDigitsAfterDecimal = 0;
	1	102		if (c == Utf8Constants.Period)
	1	103		{
		104		//
		105		// Parse the digits after the decimal point.
		106		//
		107
	1	108		srcIndex++;
	1	109		int startIndexDigitsAfterDecimal = srcIndex;
	1	110		while (srcIndex != text.Length)
	1	111		{
	1	112		c = text[srcIndex];
	1	113		if ((c - 48u) > 9)
	1	114		break;
	1	115		srcIndex++;
	1	116		}
	1	117		numDigitsAfterDecimal = srcIndex - startIndexDigitsAfterDecimal;
		118
	1	119		int startIndexOfDigitsAfterDecimalToCopy = startIndexDigitsAfterDecimal;
	1	120		if (dstIndex == 0)
	1	121		{
		122		// Not copied any digits to the Number struct yet. This means we must continue discarding leading ze
	1	123		while (startIndexOfDigitsAfterDecimalToCopy < srcIndex && text[startIndexOfDigitsAfterDecimalToCopy]
	1	124		{
	1	125		number.Scale--;
	1	126		startIndexOfDigitsAfterDecimalToCopy++;
	1	127		}
	1	128		}
		129
	1	130		int numDigitsAfterDecimalToCopy = Math.Min(srcIndex - startIndexOfDigitsAfterDecimalToCopy, NumberBuffer
	1	131		text.Slice(startIndexOfDigitsAfterDecimalToCopy, numDigitsAfterDecimalToCopy).CopyTo(digits.Slice(dstInd
	1	132		dstIndex += numDigitsAfterDecimalToCopy;
		133		// We "should" really NUL terminate, but there are multiple places we'd have to do this and it is a prec
		134
	1	135		if (srcIndex == text.Length)
	1	136		{
	1	137		if (numDigitsBeforeDecimal == 0 && numDigitsAfterDecimal == 0)
	1	138		{
		139		// For compatibility. You can say "5." and ".5" but you can't say "."
	1	140		bytesConsumed = 0;
	1	141		return false;
		142		}
		143
	1	144		bytesConsumed = srcIndex;
	1	145		number.CheckConsistency();
	1	146		return true;
		147		}
	1	148		}
		149
	1	150		if (numDigitsBeforeDecimal == 0 && numDigitsAfterDecimal == 0)
	1	151		{
	1	152		bytesConsumed = 0;
	1	153		return false;
		154		}
		155
	1	156		if ((c & ~0x20u) != 'E')
	1	157		{
	1	158		bytesConsumed = srcIndex;
	1	159		number.CheckConsistency();
	1	160		return true;
		161		}
		162
		163		//
		164		// Parse the exponent after the "E"
		165		//
	1	166		textUsedExponentNotation = true;
	1	167		srcIndex++;
		168
	1	169		if ((options & ParseNumberOptions.AllowExponent) == 0)
	1	170		{
	1	171		bytesConsumed = 0;
	1	172		return false;
		173		}
		174
	1	175		if (srcIndex == text.Length)
	1	176		{
	1	177		bytesConsumed = 0;
	1	178		return false;
		179		}
		180
	1	181		bool exponentIsNegative = false;
	1	182		c = text[srcIndex];
	1	183		switch (c)
		184		{
		185		case Utf8Constants.Minus:
	1	186		exponentIsNegative = true;
	1	187		goto case Utf8Constants.Plus;
		188
		189		case Utf8Constants.Plus:
	1	190		srcIndex++;
	1	191		if (srcIndex == text.Length)
	1	192		{
	1	193		bytesConsumed = 0;
	1	194		return false;
		195		}
	1	196		c = text[srcIndex];
	1	197		break;
		198
		199		default:
	1	200		break;
		201		}
		202
	1	203		if (!Utf8Parser.TryParseUInt32D(text.Slice(srcIndex), out uint absoluteExponent, out int bytesConsumedByExpo
	1	204		{
	1	205		bytesConsumed = 0;
	1	206		return false;
		207		}
		208
	1	209		srcIndex += bytesConsumedByExponent;
		210
	1	211		if (exponentIsNegative)
	1	212		{
	1	213		if (number.Scale < int.MinValue + (long)absoluteExponent)
	1	214		{
		215		// A scale underflow means all non-zero digits are all so far to the right of the decimal point, no
		216		// number format we have will be able to see them. Just pin the scale at the absolute minimum
		217		// and let the converter produce a 0 with the max precision available for that type.
	1	218		number.Scale = int.MinValue;
	1	219		}
		220		else
	1	221		{
	1	222		number.Scale -= (int)absoluteExponent;
	1	223		}
	1	224		}
		225		else
	1	226		{
	1	227		if (number.Scale > int.MaxValue - (long)absoluteExponent)
	1	228		{
	1	229		bytesConsumed = 0;
	1	230		return false;
		231		}
	1	232		number.Scale += (int)absoluteExponent;
	1	233		}
		234
	1	235		bytesConsumed = srcIndex;
	1	236		number.CheckConsistency();
	1	237		return true;
	1	238		}
		239		}
		240		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.BigG.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseTimeSpanBigG(ReadOnlySpan<byte> text, out TimeSpan value, out int bytesConsumed)
	1	10		{
	1	11		int srcIndex = 0;
	1	12		byte c = default;
	1	13		while (srcIndex != text.Length)
	1	14		{
	1	15		c = text[srcIndex];
	1	16		if (!(c == ' ' || c == '\t'))
	1	17		break;
	1	18		srcIndex++;
	1	19		}
		20
	1	21		if (srcIndex == text.Length)
	1	22		{
	1	23		value = default;
	1	24		bytesConsumed = 0;
	1	25		return false;
		26		}
		27
	1	28		bool isNegative = false;
	1	29		if (c == Utf8Constants.Minus)
	1	30		{
	1	31		isNegative = true;
	1	32		srcIndex++;
	1	33		if (srcIndex == text.Length)
	1	34		{
	1	35		value = default;
	1	36		bytesConsumed = 0;
	1	37		return false;
		38		}
	1	39		}
		40
	1	41		if (!TryParseUInt32D(text.Slice(srcIndex), out uint days, out int justConsumed))
	1	42		{
	1	43		value = default;
	1	44		bytesConsumed = 0;
	1	45		return false;
		46		}
	1	47		srcIndex += justConsumed;
		48
	1	49		if (srcIndex == text.Length || text[srcIndex++] != Utf8Constants.Colon)
	1	50		{
	1	51		value = default;
	1	52		bytesConsumed = 0;
	1	53		return false;
		54		}
		55
	1	56		if (!TryParseUInt32D(text.Slice(srcIndex), out uint hours, out justConsumed))
	1	57		{
	1	58		value = default;
	1	59		bytesConsumed = 0;
	1	60		return false;
		61		}
	1	62		srcIndex += justConsumed;
		63
	1	64		if (srcIndex == text.Length || text[srcIndex++] != Utf8Constants.Colon)
	1	65		{
	1	66		value = default;
	1	67		bytesConsumed = 0;
	1	68		return false;
		69		}
		70
	1	71		if (!TryParseUInt32D(text.Slice(srcIndex), out uint minutes, out justConsumed))
	1	72		{
	1	73		value = default;
	1	74		bytesConsumed = 0;
	1	75		return false;
		76		}
	1	77		srcIndex += justConsumed;
		78
	1	79		if (srcIndex == text.Length || text[srcIndex++] != Utf8Constants.Colon)
	1	80		{
	1	81		value = default;
	1	82		bytesConsumed = 0;
	1	83		return false;
		84		}
		85
	1	86		if (!TryParseUInt32D(text.Slice(srcIndex), out uint seconds, out justConsumed))
	1	87		{
	1	88		value = default;
	1	89		bytesConsumed = 0;
	1	90		return false;
		91		}
	1	92		srcIndex += justConsumed;
		93
	1	94		if (srcIndex == text.Length || text[srcIndex++] != Utf8Constants.Period)
	1	95		{
	1	96		value = default;
	1	97		bytesConsumed = 0;
	1	98		return false;
		99		}
		100
	1	101		if (!TryParseTimeSpanFraction(text.Slice(srcIndex), out uint fraction, out justConsumed))
	1	102		{
	1	103		value = default;
	1	104		bytesConsumed = 0;
	1	105		return false;
		106		}
		107
	1	108		srcIndex += justConsumed;
		109
	1	110		if (!TryCreateTimeSpan(isNegative: isNegative, days: days, hours: hours, minutes: minutes, seconds: seconds,
	1	111		{
	1	112		value = default;
	1	113		bytesConsumed = 0;
	1	114		return false;
		115		}
		116
		117		//
		118		// There cannot legally be a sixth number. If the next character is a period or colon, treat this as a error
		119		// to indicate the start of a sixth number. Otherwise, treat as end of parse with data left over.
		120		//
	1	121		if (srcIndex != text.Length && (text[srcIndex] == Utf8Constants.Period || text[srcIndex] == Utf8Constants.Co
	1	122		{
	1	123		value = default;
	1	124		bytesConsumed = 0;
	1	125		return false;
		126		}
		127
	1	128		bytesConsumed = srcIndex;
	1	129		return true;
	1	130		}
		131		}
		132		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.C.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseTimeSpanC(ReadOnlySpan<byte> text, out TimeSpan value, out int bytesConsumed)
	1	10		{
	1	11		TimeSpanSplitter s = default;
	1	12		if (!s.TrySplitTimeSpan(text, periodUsedToSeparateDay: true, out bytesConsumed))
	1	13		{
	1	14		value = default;
	1	15		return false;
		16		}
		17
	1	18		bool isNegative = s.IsNegative;
		19
		20		bool success;
	1	21		switch (s.Separators)
		22		{
		23		case 0x00000000: // dd
	1	24		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: 0, minutes: 0, seconds: 0, fr
	1	25		break;
		26
		27		case 0x01000000: // hh:mm
	1	28		success = TryCreateTimeSpan(isNegative: isNegative, days: 0, hours: s.V1, minutes: s.V2, seconds: 0,
	1	29		break;
		30
		31		case 0x02010000: // dd.hh:mm
	1	32		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: s.V2, minutes: s.V3, seconds:
	1	33		break;
		34
		35		case 0x01010000: // hh:mm:ss
	1	36		success = TryCreateTimeSpan(isNegative: isNegative, days: 0, hours: s.V1, minutes: s.V2, seconds: s.
	1	37		break;
		38
		39		case 0x02010100: // dd.hh:mm:ss
	1	40		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: s.V2, minutes: s.V3, seconds:
	1	41		break;
		42
		43		case 0x01010200: // hh:mm:ss.fffffff
	1	44		success = TryCreateTimeSpan(isNegative: isNegative, days: 0, hours: s.V1, minutes: s.V2, seconds: s.
	1	45		break;
		46
		47		case 0x02010102: // dd.hh:mm:ss.fffffff
	1	48		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: s.V2, minutes: s.V3, seconds:
	1	49		break;
		50
		51		default:
	1	52		value = default;
	1	53		success = false;
	1	54		break;
		55		}
		56
	1	57		if (!success)
	1	58		{
	1	59		bytesConsumed = 0;
	1	60		return false;
		61		}
		62
	1	63		return true;
	1	64		}
		65		}
		66		}
		67

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.cs

	#	Line		Line coverage
		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		/// <summary>
		12		/// Parses a TimeSpan at the start of a Utf8 string.
		13		/// </summary>
		14		/// <param name="text">The Utf8 string to parse</param>
		15		/// <param name="value">Receives the parsed value</param>
		16		/// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was pa
		17		/// <param name="standardFormat">Expected format of the Utf8 string</param>
		18		/// <returns>
		19		/// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed.
		20		/// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set
		21		/// </returns>
		22		/// <remarks>
		23		/// Formats supported:
		24		///     c/t/T (default) [-][d.]hh:mm:ss[.fffffff]             (constant format)
		25		///     G               [-]d:hh:mm:ss.fffffff                 (general long)
		26		///     g               [-][d:]h:mm:ss[.f[f[f[f[f[f[f[]]]]]]] (general short)
		27		/// </remarks>
		28		/// <exceptions>
		29		/// <cref>System.FormatException</cref> if the format is not valid for this data type.
		30		/// </exceptions>
		31		public static bool TryParse(ReadOnlySpan<byte> text, out TimeSpan value, out int bytesConsumed, char standardFor
	1	32		{
	1	33		switch (standardFormat)
		34		{
		35		case (default):
		36		case 'c':
		37		case 't':
		38		case 'T':
	1	39		return TryParseTimeSpanC(text, out value, out bytesConsumed);
		40
		41		case 'G':
	1	42		return TryParseTimeSpanBigG(text, out value, out bytesConsumed);
		43
		44		case 'g':
	1	45		return TryParseTimeSpanLittleG(text, out value, out bytesConsumed);
		46
		47		default:
	1	48		return ThrowHelper.TryParseThrowFormatException(out value, out bytesConsumed);
		49		}
	1	50		}
		51
		52		/// <summary>
		53		/// Parse the fraction portion of a TimeSpan. Must be 1..7 digits. If fewer than 7, zeroes are implied to the ri
		54		/// parser rejects the string (even if the extra digits are all zeroes.)
		55		/// </summary>
		56		private static bool TryParseTimeSpanFraction(ReadOnlySpan<byte> text, out uint value, out int bytesConsumed)
	1	57		{
	1	58		int srcIndex = 0;
		59
	1	60		if (srcIndex == text.Length)
	1	61		{
	1	62		value = default;
	1	63		bytesConsumed = 0;
	1	64		return false;
		65		}
		66
	1	67		uint digit = text[srcIndex] - 48u; // '0'
	1	68		if (digit > 9)
	1	69		{
	1	70		value = default;
	1	71		bytesConsumed = 0;
	1	72		return false;
		73		}
	1	74		srcIndex++;
		75
	1	76		uint fraction = digit;
	1	77		int digitCount = 1;
		78
	1	79		while (srcIndex != text.Length)
	1	80		{
	1	81		digit = text[srcIndex] - 48u; // '0'
	1	82		if (digit > 9)
	1	83		break;
	1	84		srcIndex++;
	1	85		digitCount++;
	1	86		if (digitCount > Utf8Constants.DateTimeNumFractionDigits)
	1	87		{
		88		// Yes, TimeSpan fraction parsing is that picky.
	1	89		value = default;
	1	90		bytesConsumed = 0;
	1	91		return false;
		92		}
	1	93		fraction = 10 * fraction + digit;
	1	94		}
		95
	1	96		switch (digitCount)
		97		{
		98		case 7:
	1	99		break;
		100
		101		case 6:
	1	102		fraction *= 10;
	1	103		break;
		104
		105		case 5:
	1	106		fraction *= 100;
	1	107		break;
		108
		109		case 4:
	1	110		fraction *= 1000;
	1	111		break;
		112
		113		case 3:
	1	114		fraction *= 10000;
	1	115		break;
		116
		117		case 2:
	1	118		fraction *= 100000;
	1	119		break;
		120
		121		default:
	1	122		Debug.Assert(digitCount == 1);
	1	123		fraction *= 1000000;
	1	124		break;
		125		}
		126
	1	127		value = fraction;
	1	128		bytesConsumed = srcIndex;
	1	129		return true;
	1	130		}
		131
		132		/// <summary>
		133		/// Overflow-safe TryCreateTimeSpan
		134		/// </summary>
		135		private static bool TryCreateTimeSpan(bool isNegative, uint days, uint hours, uint minutes, uint seconds, uint f
	1	136		{
		137		const long MaxMilliSeconds = long.MaxValue / TimeSpan.TicksPerMillisecond;
		138		const long MinMilliSeconds = long.MinValue / TimeSpan.TicksPerMillisecond;
		139
	1	140		Debug.Assert(days >= 0 && hours >= 0 && minutes >= 0 && seconds >= 00 && fraction >= 0);
	1	141		if (hours > 23 || minutes > 59 || seconds > 59)
	1	142		{
	1	143		timeSpan = default;
	1	144		return false;
		145		}
		146
	1	147		Debug.Assert(fraction <= Utf8Constants.MaxDateTimeFraction); // This value comes from TryParseTimeSpanFracti
		148
	1	149		long millisecondsWithoutFraction = (((long)days) * 3600 * 24 + ((long)hours) * 3600 + ((long)minutes) * 60 +
		150
		151		long ticks;
	1	152		if (isNegative)
	1	153		{
	1	154		millisecondsWithoutFraction = -millisecondsWithoutFraction;
	1	155		if (millisecondsWithoutFraction < MinMilliSeconds)
	1	156		{
	1	157		timeSpan = default;
	1	158		return false;
		159		}
		160
	1	161		long ticksWithoutFraction = millisecondsWithoutFraction * TimeSpan.TicksPerMillisecond;
	1	162		if (ticksWithoutFraction < long.MinValue + fraction)
	1	163		{
	1	164		timeSpan = default;
	1	165		return false;
		166		}
		167
	1	168		ticks = ticksWithoutFraction - fraction;
	1	169		}
		170		else
	1	171		{
	1	172		if (millisecondsWithoutFraction > MaxMilliSeconds)
	1	173		{
	1	174		timeSpan = default;
	1	175		return false;
		176		}
		177
	1	178		long ticksWithoutFraction = millisecondsWithoutFraction * TimeSpan.TicksPerMillisecond;
	1	179		if (ticksWithoutFraction > long.MaxValue - fraction)
	1	180		{
	1	181		timeSpan = default;
	1	182		return false;
		183		}
		184
	1	185		ticks = ticksWithoutFraction + fraction;
	1	186		}
		187
	1	188		timeSpan = new TimeSpan(ticks);
	1	189		return true;
	1	190		}
		191		}
		192		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.LittleG.cs

	#	Line		Line coverage
		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		namespace System.Buffers.Text
		6		{
		7		public static partial class Utf8Parser
		8		{
		9		private static bool TryParseTimeSpanLittleG(ReadOnlySpan<byte> text, out TimeSpan value, out int bytesConsumed)
	1	10		{
	1	11		TimeSpanSplitter s = default;
	1	12		if (!s.TrySplitTimeSpan(text, periodUsedToSeparateDay: false, out bytesConsumed))
	1	13		{
	1	14		value = default;
	1	15		return false;
		16		}
		17
	1	18		bool isNegative = s.IsNegative;
		19
		20		bool success;
	1	21		switch (s.Separators)
		22		{
		23		case 0x00000000: // dd
	1	24		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: 0, minutes: 0, seconds: 0, fr
	1	25		break;
		26
		27		case 0x01000000: // hh:mm
	1	28		success = TryCreateTimeSpan(isNegative: isNegative, days: 0, hours: s.V1, minutes: s.V2, seconds: 0,
	1	29		break;
		30
		31		case 0x01010000: // hh:mm:ss
	1	32		success = TryCreateTimeSpan(isNegative: isNegative, days: 0, hours: s.V1, minutes: s.V2, seconds: s.
	1	33		break;
		34
		35		case 0x01010100: // dd:hh:mm:ss
	1	36		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: s.V2, minutes: s.V3, seconds:
	1	37		break;
		38
		39		case 0x01010200: // hh:mm:ss.fffffff
	1	40		success = TryCreateTimeSpan(isNegative: isNegative, days: 0, hours: s.V1, minutes: s.V2, seconds: s.
	1	41		break;
		42
		43		case 0x01010102: // dd:hh:mm:ss.fffffff
	1	44		success = TryCreateTimeSpan(isNegative: isNegative, days: s.V1, hours: s.V2, minutes: s.V3, seconds:
	1	45		break;
		46
		47		default:
	1	48		value = default;
	1	49		success = false;
	1	50		break;
		51		}
		52
	1	53		if (!success)
	1	54		{
	1	55		bytesConsumed = 0;
	1	56		return false;
		57		}
		58
	1	59		return true;
	1	60		}
		61		}
		62		}

C:\GitHub\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpanSplitter.cs

	#	Line		Line coverage
		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		private enum ComponentParseResult : byte
		12		{
		13		// Do not change or add values in this enum unless you review every use of the TimeSpanSplitter.Separators f
		14		// ComponentParseResults" encoded as a 32-bit integer with each of its four bytes containing one of 0 (NoMor
		15		// (So a value of 0x01010200 means the string parsed as "nn:nn:nn.nnnnnnn")
		16		NoMoreData = 0,
		17		Colon = 1,
		18		Period = 2,
		19		ParseFailure = 3,
		20		}
		21
		22		private struct TimeSpanSplitter
		23		{
		24		public uint V1;
		25		public uint V2;
		26		public uint V3;
		27		public uint V4;
		28		public uint V5;
		29
		30		public bool IsNegative;
		31
		32		// Encodes an "array of four ComponentParseResults" as a 32-bit integer with each of its four bytes containi
		33		// (So a value of 0x01010200 means the string parsed as "nn:nn:nn.nnnnnnn")
		34		public uint Separators;
		35
		36		public bool TrySplitTimeSpan(ReadOnlySpan<byte> text, bool periodUsedToSeparateDay, out int bytesConsumed)
	1	37		{
	1	38		int srcIndex = 0;
	1	39		byte c = default;
		40
		41		// Unlike many other data types, TimeSpan allow leading whitespace.
	1	42		while (srcIndex != text.Length)
	1	43		{
	1	44		c = text[srcIndex];
	1	45		if (!(c == ' ' || c == '\t'))
	1	46		break;
	1	47		srcIndex++;
	1	48		}
		49
	1	50		if (srcIndex == text.Length)
	1	51		{
	1	52		bytesConsumed = 0;
	1	53		return false;
		54		}
		55
		56		// Check for an option negative sign. ('+' is not allowed.)
	1	57		if (c == Utf8Constants.Minus)
	1	58		{
	1	59		IsNegative = true;
	1	60		srcIndex++;
	1	61		if (srcIndex == text.Length)
	1	62		{
	1	63		bytesConsumed = 0;
	1	64		return false;
		65		}
	1	66		}
		67
		68		// From here, we terminate on anything that's not a digit, ':' or '.' The '.' is only allowed after at l
		69		// been specified. If we see it earlier, we'll assume that's an error and fail out rather than treating
		70
		71		//
		72		// Timespan has to start with a number - parse the first one.
		73		//
	1	74		if (!TryParseUInt32D(text.Slice(srcIndex), out V1, out int justConsumed))
	1	75		{
	1	76		bytesConsumed = 0;
	1	77		return false;
		78		}
	1	79		srcIndex += justConsumed;
		80
		81		ComponentParseResult result;
		82
		83		//
		84		// Split out the second number (if any) For the 'c' format, a period might validly appear here as it;s u
		85		// the fraction is always the fourth component at earliest, so if we do see a period at this stage, alwa
		86		// a fraction.
		87		//
	1	88		result = ParseComponent(text, neverParseAsFraction: periodUsedToSeparateDay, ref srcIndex, out V2);
	1	89		if (result == ComponentParseResult.ParseFailure)
	1	90		{
	1	91		bytesConsumed = 0;
	1	92		return false;
		93		}
	1	94		else if (result == ComponentParseResult.NoMoreData)
	1	95		{
	1	96		bytesConsumed = srcIndex;
	1	97		return true;
		98		}
		99		else
	1	100		{
	1	101		Debug.Assert(result == ComponentParseResult.Colon || result == ComponentParseResult.Period);
	1	102		Separators |= ((uint)result) << 24;
	1	103		}
		104
		105		//
		106		// Split out the third number (if any)
		107		//
	1	108		result = ParseComponent(text, false, ref srcIndex, out V3);
	1	109		if (result == ComponentParseResult.ParseFailure)
	1	110		{
	1	111		bytesConsumed = 0;
	1	112		return false;
		113		}
	1	114		else if (result == ComponentParseResult.NoMoreData)
	1	115		{
	1	116		bytesConsumed = srcIndex;
	1	117		return true;
		118		}
		119		else
	1	120		{
	1	121		Debug.Assert(result == ComponentParseResult.Colon || result == ComponentParseResult.Period);
	1	122		Separators |= ((uint)result) << 16;
	1	123		}
		124
		125		//
		126		// Split out the fourth number (if any)
		127		//
	1	128		result = ParseComponent(text, false, ref srcIndex, out V4);
	1	129		if (result == ComponentParseResult.ParseFailure)
	1	130		{
	1	131		bytesConsumed = 0;
	1	132		return false;
		133		}
	1	134		else if (result == ComponentParseResult.NoMoreData)
	1	135		{
	1	136		bytesConsumed = srcIndex;
	1	137		return true;
		138		}
		139		else
	1	140		{
	1	141		Debug.Assert(result == ComponentParseResult.Colon || result == ComponentParseResult.Period);
	1	142		Separators |= ((uint)result) << 8;
	1	143		}
		144
		145		//
		146		// Split out the fifth number (if any)
		147		//
	1	148		result = ParseComponent(text, false, ref srcIndex, out V5);
	1	149		if (result == ComponentParseResult.ParseFailure)
	1	150		{
	1	151		bytesConsumed = 0;
	1	152		return false;
		153		}
	1	154		else if (result == ComponentParseResult.NoMoreData)
	1	155		{
	1	156		bytesConsumed = srcIndex;
	1	157		return true;
		158		}
		159		else
	1	160		{
	1	161		Debug.Assert(result == ComponentParseResult.Colon || result == ComponentParseResult.Period);
	1	162		Separators |= (uint)result;
	1	163		}
		164
		165		//
		166		// There cannot legally be a sixth number. If the next character is a period or colon, treat this as a e
		167		// to indicate the start of a sixth number. Otherwise, treat as end of parse with data left over.
		168		//
	1	169		if (srcIndex != text.Length && (text[srcIndex] == Utf8Constants.Period || text[srcIndex] == Utf8Constant
	1	170		{
	1	171		bytesConsumed = 0;
	1	172		return false;
		173		}
		174
	1	175		bytesConsumed = srcIndex;
	1	176		return true;
	1	177		}
		178
		179		//
		180		// Look for a separator followed by an unsigned integer.
		181		//
		182		private static ComponentParseResult ParseComponent(ReadOnlySpan<byte> text, bool neverParseAsFraction, ref i
	1	183		{
	1	184		if (srcIndex == text.Length)
	1	185		{
	1	186		value = default;
	1	187		return ComponentParseResult.NoMoreData;
		188		}
		189
	1	190		byte c = text[srcIndex];
	1	191		if (c == Utf8Constants.Colon || (c == Utf8Constants.Period && neverParseAsFraction))
	1	192		{
	1	193		srcIndex++;
		194
	1	195		if (!TryParseUInt32D(text.Slice(srcIndex), out value, out int bytesConsumed))
	1	196		{
	1	197		value = default;
	1	198		return ComponentParseResult.ParseFailure;
		199		}
		200
	1	201		srcIndex += bytesConsumed;
	1	202		return c == Utf8Constants.Colon ? ComponentParseResult.Colon : ComponentParseResult.Period;
		203		}
	1	204		else if (c == Utf8Constants.Period)
	1	205		{
	1	206		srcIndex++;
		207
	1	208		if (!TryParseTimeSpanFraction(text.Slice(srcIndex), out value, out int bytesConsumed))
	1	209		{
	1	210		value = default;
	1	211		return ComponentParseResult.ParseFailure;
		212		}
		213
	1	214		srcIndex += bytesConsumed;
	1	215		return ComponentParseResult.Period;
		216		}
		217		else
	1	218		{
	1	219		value = default;
	1	220		return ComponentParseResult.NoMoreData;
		221		}
	1	222		}
		223		}
		224		}
		225		}