?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Contribute to IDE0044 (make field readonly)
[mono-project.git] / netcore / System.Private.CoreLib / shared / System / Globalization / TimeSpanParse.cs
blob7dfac05aaddc4ef5483dabcac37c87eed166bbb2
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 ////////////////////////////////////////////////////////////////////////////
6 //
7 // Purpose: Used by TimeSpan to parse a time interval string.
8 //
9 // Standard Format:
10 // -=-=-=-=-=-=-=-
11 // "c": Constant format. [-][d'.']hh':'mm':'ss['.'fffffff]
12 // Not culture sensitive. Default format (and null/empty format string) map to this format.
13 //
14 // "g": General format, short: [-][d':']h':'mm':'ss'.'FFFFFFF
15 // Only print what's needed. Localized (if you want Invariant, pass in Invariant).
16 // The fractional seconds separator is localized, equal to the culture's DecimalSeparator.
17 //
18 // "G": General format, long: [-]d':'hh':'mm':'ss'.'fffffff
19 // Always print days and 7 fractional digits. Localized (if you want Invariant, pass in Invariant).
20 // The fractional seconds separator is localized, equal to the culture's DecimalSeparator.
21 //
22 // * "TryParseTimeSpan" is the main method for Parse/TryParse
23 //
24 // - TimeSpanTokenizer.GetNextToken() is used to split the input string into number and literal tokens.
25 // - TimeSpanRawInfo.ProcessToken() adds the next token into the parsing intermediary state structure
26 // - ProcessTerminalState() uses the fully initialized TimeSpanRawInfo to find a legal parse match.
27 // The terminal states are attempted as follows:
28 // foreach (+InvariantPattern, -InvariantPattern, +LocalizedPattern, -LocalizedPattern) try
29 // 1 number => d
30 // 2 numbers => h:m
31 // 3 numbers => h:m:s | d.h:m | h:m:.f
32 // 4 numbers => h:m:s.f | d.h:m:s | d.h:m:.f
33 // 5 numbers => d.h:m:s.f
34 //
35 // Custom Format:
36 // -=-=-=-=-=-=-=
37 //
38 // * "TryParseExactTimeSpan" is the main method for ParseExact/TryParseExact methods
39 // * "TryParseExactMultipleTimeSpan" is the main method for ParseExact/TryparseExact
40 // methods that take a string[] of formats
41 //
42 // - For single-letter formats "TryParseTimeSpan" is called (see above)
43 // - For multi-letter formats "TryParseByFormat" is called
44 // - TryParseByFormat uses helper methods (ParseExactLiteral, ParseExactDigits, etc)
45 // which drive the underlying TimeSpanTokenizer. However, unlike standard formatting which
46 // operates on whole-tokens, ParseExact operates at the character-level. As such,
47 // TimeSpanTokenizer.NextChar and TimeSpanTokenizer.BackOne() are called directly.
48 //
49 ////////////////////////////////////////////////////////////////////////////
50
51 using System.Diagnostics;
52 using System.Text;
53
54 namespace System.Globalization
55 {
56 internal static class TimeSpanParse
57 {
58 private const int MaxFractionDigits = 7;
59 private const int MaxDays = 10675199;
60 private const int MaxHours = 23;
61 private const int MaxMinutes = 59;
62 private const int MaxSeconds = 59;
63 private const int MaxFraction = 9999999;
64
65 [Flags]
66 private enum TimeSpanStandardStyles : byte
67 {
68 // Standard Format Styles
69 None = 0x00000000,
70 Invariant = 0x00000001, //Allow Invariant Culture
71 Localized = 0x00000002, //Allow Localized Culture
72 RequireFull = 0x00000004, //Require the input to be in DHMSF format
73 Any = Invariant | Localized,
74 }
75
76 // TimeSpan Token Types
77 private enum TTT : byte
78 {
79 None = 0, // None of the TimeSpanToken fields are set
80 End = 1, // '\0'
81 Num = 2, // Number
82 Sep = 3, // literal
83 NumOverflow = 4, // Number that overflowed
84 }
85
86 private ref struct TimeSpanToken
87 {
88 internal TTT _ttt;
89 internal int _num; // Store the number that we are parsing (if any)
90 internal int _zeroes; // Store the number of leading zeroes (if any)
91 internal ReadOnlySpan<char> _sep; // Store the literal that we are parsing (if any)
92
93 public TimeSpanToken(TTT type) : this(type, 0, 0, default) { }
94
95 public TimeSpanToken(int number) : this(TTT.Num, number, 0, default) { }
96
97 public TimeSpanToken(int number, int leadingZeroes) : this(TTT.Num, number, leadingZeroes, default) { }
98
99 public TimeSpanToken(TTT type, int number, int leadingZeroes, ReadOnlySpan<char> separator)
100 {
101 _ttt = type;
102 _num = number;
103 _zeroes = leadingZeroes;
104 _sep = separator;
105 }
106
107 public bool NormalizeAndValidateFraction()
108 {
109 Debug.Assert(_ttt == TTT.Num);
110 Debug.Assert(_num > -1);
111
112 if (_num == 0)
113 return true;
114
115 if (_zeroes == 0 && _num > MaxFraction)
116 return false;
117
118 int totalDigitsCount = ((int) Math.Floor(Math.Log10(_num))) + 1 + _zeroes;
119
120 if (totalDigitsCount == MaxFractionDigits)
121 {
122 // Already normalized. no more action needed
123 // .9999999 normalize to 9,999,999 ticks
124 // .0000001 normalize to 1 ticks
125 return true;
126 }
127
128 if (totalDigitsCount < MaxFractionDigits)
129 {
130 // normalize the fraction to the 7-digits
131 // .999999 normalize to 9,999,990 ticks
132 // .99999 normalize to 9,999,900 ticks
133 // .000001 normalize to 10 ticks
134 // .1 normalize to 1,000,000 ticks
135
136 _num *= (int) Pow10(MaxFractionDigits - totalDigitsCount);
137 return true;
138 }
139
140 // totalDigitsCount is greater then MaxFractionDigits, we'll need to do the rounding to 7-digits length
141 // .00000001 normalized to 0 ticks
142 // .00000005 normalized to 1 ticks
143 // .09999999 normalize to 1,000,000 ticks
144 // .099999999 normalize to 1,000,000 ticks
145
146 Debug.Assert(_zeroes > 0); // Already validated that in the condition _zeroes == 0 && _num > MaxFraction
147 _num = (int) Math.Round((double)_num / Pow10(totalDigitsCount - MaxFractionDigits), MidpointRounding.AwayFromZero);
148 Debug.Assert(_num < MaxFraction);
149
150 return true;
151 }
152 }
153
154 private ref struct TimeSpanTokenizer
155 {
156 private readonly ReadOnlySpan<char> _value;
157 private int _pos;
158
159 internal TimeSpanTokenizer(ReadOnlySpan<char> input) : this(input, 0) { }
160
161 internal TimeSpanTokenizer(ReadOnlySpan<char> input, int startPosition)
162 {
163 _value = input;
164 _pos = startPosition;
165 }
166
167 /// <summary>Returns the next token in the input string</summary>
168 /// <remarks>Used by the parsing routines that operate on standard-formats.</remarks>
169 internal TimeSpanToken GetNextToken()
170 {
171 // Get the position of the next character to be processed. If there is no
172 // next character, we're at the end.
173 int pos = _pos;
174 Debug.Assert(pos > -1);
175 if (pos >= _value.Length)
176 {
177 return new TimeSpanToken(TTT.End);
178 }
179
180 // Now retrieve that character. If it's a digit, we're processing a number.
181 int num = _value[pos] - '0';
182 if ((uint)num <= 9)
183 {
184 int zeroes = 0;
185 if (num == 0)
186 {
187 // Read all leading zeroes.
188 zeroes = 1;
189 while (true)
190 {
191 int digit;
192 if (++_pos >= _value.Length || (uint)(digit = _value[_pos] - '0') > 9)
193 {
194 return new TimeSpanToken(TTT.Num, 0, zeroes, default);
195 }
196
197 if (digit == 0)
198 {
199 zeroes++;
200 continue;
201 }
202
203 num = digit;
204 break;
205 }
206 }
207
208 // Continue to read as long as we're reading digits.
209 while (++_pos < _value.Length)
210 {
211 int digit = _value[_pos] - '0';
212 if ((uint)digit > 9)
213 {
214 break;
215 }
216
217 num = num * 10 + digit;
218 if ((num & 0xF0000000) != 0) // Max limit we can support 268435455 which is FFFFFFF
219 {
220 return new TimeSpanToken(TTT.NumOverflow);
221 }
222 }
223
224 return new TimeSpanToken(TTT.Num, num, zeroes, default);
225 }
226
227 // Otherwise, we're processing a separator, and we've already processed the first
228 // character of it. Continue processing characters as long as they're not digits.
229 int length = 1;
230 while (true)
231 {
232 if (++_pos >= _value.Length || (uint)(_value[_pos] - '0') <= 9)
233 {
234 break;
235 }
236 length++;
237 }
238
239 // Return the separator.
240 return new TimeSpanToken(TTT.Sep, 0, 0, _value.Slice(pos, length));
241 }
242
243 internal bool EOL => _pos >= (_value.Length - 1);
244
245 internal void BackOne()
246 {
247 if (_pos > 0) --_pos;
248 }
249
250 internal char NextChar
251 {
252 get
253 {
254 int pos = ++_pos;
255 return (uint)pos < (uint)_value.Length ?
256 _value[pos] :
257 (char)0;
258 }
259 }
260 }
261
262 /// <summary>Stores intermediary parsing state for the standard formats.</summary>
263 private ref struct TimeSpanRawInfo
264 {
265 internal TimeSpanFormat.FormatLiterals PositiveInvariant => TimeSpanFormat.PositiveInvariantFormatLiterals;
266 internal TimeSpanFormat.FormatLiterals NegativeInvariant => TimeSpanFormat.NegativeInvariantFormatLiterals;
267
268 internal TimeSpanFormat.FormatLiterals PositiveLocalized
269 {
270 get
271 {
272 if (!_posLocInit)
273 {
274 _posLoc = new TimeSpanFormat.FormatLiterals();
275 _posLoc.Init(_fullPosPattern, false);
276 _posLocInit = true;
277 }
278 return _posLoc;
279 }
280 }
281
282 internal TimeSpanFormat.FormatLiterals NegativeLocalized
283 {
284 get
285 {
286 if (!_negLocInit)
287 {
288 _negLoc = new TimeSpanFormat.FormatLiterals();
289 _negLoc.Init(_fullNegPattern, false);
290 _negLocInit = true;
291 }
292 return _negLoc;
293 }
294 }
295
296 internal bool FullAppCompatMatch(TimeSpanFormat.FormatLiterals pattern) =>
297 _sepCount == 5
298 && _numCount == 4
299 && _literals0.EqualsOrdinal(pattern.Start)
300 && _literals1.EqualsOrdinal(pattern.DayHourSep)
301 && _literals2.EqualsOrdinal(pattern.HourMinuteSep)
302 && _literals3.EqualsOrdinal(pattern.AppCompatLiteral)
303 && _literals4.EqualsOrdinal(pattern.End);
304
305 internal bool PartialAppCompatMatch(TimeSpanFormat.FormatLiterals pattern) =>
306 _sepCount == 4
307 && _numCount == 3
308 && _literals0.EqualsOrdinal(pattern.Start)
309 && _literals1.EqualsOrdinal(pattern.HourMinuteSep)
310 && _literals2.EqualsOrdinal(pattern.AppCompatLiteral)
311 && _literals3.EqualsOrdinal(pattern.End);
312
313 /// <summary>DHMSF (all values matched)</summary>
314 internal bool FullMatch(TimeSpanFormat.FormatLiterals pattern) =>
315 _sepCount == MaxLiteralTokens
316 && _numCount == MaxNumericTokens
317 && _literals0.EqualsOrdinal(pattern.Start)
318 && _literals1.EqualsOrdinal(pattern.DayHourSep)
319 && _literals2.EqualsOrdinal(pattern.HourMinuteSep)
320 && _literals3.EqualsOrdinal(pattern.MinuteSecondSep)
321 && _literals4.EqualsOrdinal(pattern.SecondFractionSep)
322 && _literals5.EqualsOrdinal(pattern.End);
323
324 /// <summary>D (no hours, minutes, seconds, or fractions)</summary>
325 internal bool FullDMatch(TimeSpanFormat.FormatLiterals pattern) =>
326 _sepCount == 2
327 && _numCount == 1
328 && _literals0.EqualsOrdinal(pattern.Start)
329 && _literals1.EqualsOrdinal(pattern.End);
330
331 /// <summary>HM (no days, seconds, or fractions)</summary>
332 internal bool FullHMMatch(TimeSpanFormat.FormatLiterals pattern) =>
333 _sepCount == 3
334 && _numCount == 2
335 && _literals0.EqualsOrdinal(pattern.Start)
336 && _literals1.EqualsOrdinal(pattern.HourMinuteSep)
337 && _literals2.EqualsOrdinal(pattern.End);
338
339 /// <summary>DHM (no seconds or fraction)</summary>
340 internal bool FullDHMMatch(TimeSpanFormat.FormatLiterals pattern) =>
341 _sepCount == 4
342 && _numCount == 3
343 && _literals0.EqualsOrdinal(pattern.Start)
344 && _literals1.EqualsOrdinal(pattern.DayHourSep)
345 && _literals2.EqualsOrdinal(pattern.HourMinuteSep)
346 && _literals3.EqualsOrdinal(pattern.End);
347
348 /// <summary>HMS (no days or fraction)</summary>
349 internal bool FullHMSMatch(TimeSpanFormat.FormatLiterals pattern) =>
350 _sepCount == 4
351 && _numCount == 3
352 && _literals0.EqualsOrdinal(pattern.Start)
353 && _literals1.EqualsOrdinal(pattern.HourMinuteSep)
354 && _literals2.EqualsOrdinal(pattern.MinuteSecondSep)
355 && _literals3.EqualsOrdinal(pattern.End);
356
357 /// <summary>DHMS (no fraction)</summary>
358 internal bool FullDHMSMatch(TimeSpanFormat.FormatLiterals pattern) =>
359 _sepCount == 5
360 && _numCount == 4
361 && _literals0.EqualsOrdinal(pattern.Start)
362 && _literals1.EqualsOrdinal(pattern.DayHourSep)
363 && _literals2.EqualsOrdinal(pattern.HourMinuteSep)
364 && _literals3.EqualsOrdinal(pattern.MinuteSecondSep)
365 && _literals4.EqualsOrdinal(pattern.End);
366
367 /// <summary>HMSF (no days)</summary>
368 internal bool FullHMSFMatch(TimeSpanFormat.FormatLiterals pattern) =>
369 _sepCount == 5
370 && _numCount == 4
371 && _literals0.EqualsOrdinal(pattern.Start)
372 && _literals1.EqualsOrdinal(pattern.HourMinuteSep)
373 && _literals2.EqualsOrdinal(pattern.MinuteSecondSep)
374 && _literals3.EqualsOrdinal(pattern.SecondFractionSep)
375 && _literals4.EqualsOrdinal(pattern.End);
376
377 internal TTT _lastSeenTTT;
378 internal int _tokenCount;
379 internal int _sepCount;
380 internal int _numCount;
381
382 private TimeSpanFormat.FormatLiterals _posLoc;
383 private TimeSpanFormat.FormatLiterals _negLoc;
384 private bool _posLocInit;
385 private bool _negLocInit;
386 private string _fullPosPattern;
387 private string _fullNegPattern;
388
389 private const int MaxTokens = 11;
390 private const int MaxLiteralTokens = 6;
391 private const int MaxNumericTokens = 5;
392
393 internal TimeSpanToken _numbers0, _numbers1, _numbers2, _numbers3, _numbers4; // MaxNumbericTokens = 5
394 internal ReadOnlySpan<char> _literals0, _literals1, _literals2, _literals3, _literals4, _literals5; // MaxLiteralTokens=6
395
396 internal void Init(DateTimeFormatInfo dtfi)
397 {
398 Debug.Assert(dtfi != null);
399
400 _lastSeenTTT = TTT.None;
401 _tokenCount = 0;
402 _sepCount = 0;
403 _numCount = 0;
404
405 _fullPosPattern = dtfi.FullTimeSpanPositivePattern;
406 _fullNegPattern = dtfi.FullTimeSpanNegativePattern;
407 _posLocInit = false;
408 _negLocInit = false;
409 }
410
411 internal bool ProcessToken(ref TimeSpanToken tok, ref TimeSpanResult result)
412 {
413 switch (tok._ttt)
414 {
415 case TTT.Num:
416 if ((_tokenCount == 0 && !AddSep(default, ref result)) || !AddNum(tok, ref result))
417 {
418 return false;
419 }
420 break;
421
422 case TTT.Sep:
423 if (!AddSep(tok._sep, ref result))
424 {
425 return false;
426 }
427 break;
428
429 case TTT.NumOverflow:
430 return result.SetOverflowFailure();
431
432 default:
433 // Some unknown token or a repeat token type in the input
434 return result.SetBadTimeSpanFailure();
435 }
436
437 _lastSeenTTT = tok._ttt;
438 Debug.Assert(_tokenCount == (_sepCount + _numCount), "tokenCount == (SepCount + NumCount)");
439 return true;
440 }
441
442 private bool AddSep(ReadOnlySpan<char> sep, ref TimeSpanResult result)
443 {
444 if (_sepCount >= MaxLiteralTokens || _tokenCount >= MaxTokens)
445 {
446 return result.SetBadTimeSpanFailure();
447 }
448
449 switch (_sepCount++)
450 {
451 case 0: _literals0 = sep; break;
452 case 1: _literals1 = sep; break;
453 case 2: _literals2 = sep; break;
454 case 3: _literals3 = sep; break;
455 case 4: _literals4 = sep; break;
456 default: _literals5 = sep; break;
457 }
458
459 _tokenCount++;
460 return true;
461 }
462 private bool AddNum(TimeSpanToken num, ref TimeSpanResult result)
463 {
464 if (_numCount >= MaxNumericTokens || _tokenCount >= MaxTokens)
465 {
466 return result.SetBadTimeSpanFailure();
467 }
468
469 switch (_numCount++)
470 {
471 case 0: _numbers0 = num; break;
472 case 1: _numbers1 = num; break;
473 case 2: _numbers2 = num; break;
474 case 3: _numbers3 = num; break;
475 default: _numbers4 = num; break;
476 }
477
478 _tokenCount++;
479 return true;
480 }
481 }
482
483 /// <summary>Store the result of the parsing.</summary>
484 private ref struct TimeSpanResult
485 {
486 internal TimeSpan parsedTimeSpan;
487 private readonly bool _throwOnFailure;
488 private readonly ReadOnlySpan<char> _originalTimeSpanString;
489
490 internal TimeSpanResult(bool throwOnFailure, ReadOnlySpan<char> originalTimeSpanString)
491 {
492 parsedTimeSpan = default;
493 _throwOnFailure = throwOnFailure;
494 _originalTimeSpanString = originalTimeSpanString;
495 }
496
497 internal bool SetNoFormatSpecifierFailure()
498 {
499 if (!_throwOnFailure)
500 {
501 return false;
502 }
503
504 throw new FormatException(SR.Format_NoFormatSpecifier);
505 }
506
507 internal bool SetBadQuoteFailure(char failingCharacter)
508 {
509 if (!_throwOnFailure)
510 {
511 return false;
512 }
513
514 throw new FormatException(SR.Format(SR.Format_BadQuote, failingCharacter));
515 }
516
517 internal bool SetInvalidStringFailure()
518 {
519 if (!_throwOnFailure)
520 {
521 return false;
522 }
523
524 throw new FormatException(SR.Format_InvalidString);
525 }
526
527 internal bool SetArgumentNullFailure(string argumentName)
528 {
529 if (!_throwOnFailure)
530 {
531 return false;
532 }
533
534 Debug.Assert(argumentName != null);
535 throw new ArgumentNullException(argumentName, SR.ArgumentNull_String);
536 }
537
538 internal bool SetOverflowFailure()
539 {
540 if (!_throwOnFailure)
541 {
542 return false;
543 }
544
545 throw new OverflowException(SR.Format(SR.Overflow_TimeSpanElementTooLarge, new string(_originalTimeSpanString)));
546 }
547
548 internal bool SetBadTimeSpanFailure()
549 {
550 if (!_throwOnFailure)
551 {
552 return false;
553 }
554
555 throw new FormatException(SR.Format(SR.Format_BadTimeSpan, new string(_originalTimeSpanString)));
556 }
557
558 internal bool SetBadFormatSpecifierFailure(char? formatSpecifierCharacter = null)
559 {
560 if (!_throwOnFailure)
561 {
562 return false;
563 }
564
565 throw new FormatException(SR.Format(SR.Format_BadFormatSpecifier, formatSpecifierCharacter));
566 }
567 }
568
569 internal static long Pow10(int pow)
570 {
571 switch (pow)
572 {
573 case 0: return 1;
574 case 1: return 10;
575 case 2: return 100;
576 case 3: return 1000;
577 case 4: return 10000;
578 case 5: return 100000;
579 case 6: return 1000000;
580 case 7: return 10000000;
581 default: return (long)Math.Pow(10, pow);
582 }
583 }
584
585 private static bool TryTimeToTicks(bool positive, TimeSpanToken days, TimeSpanToken hours, TimeSpanToken minutes, TimeSpanToken seconds, TimeSpanToken fraction, out long result)
586 {
587 if (days._num > MaxDays ||
588 hours._num > MaxHours ||
589 minutes._num > MaxMinutes ||
590 seconds._num > MaxSeconds ||
591 !fraction.NormalizeAndValidateFraction())
592 {
593 result = 0;
594 return false;
595 }
596
597 long ticks = ((long)days._num * 3600 * 24 + (long)hours._num * 3600 + (long)minutes._num * 60 + seconds._num) * 1000;
598 if (ticks > InternalGlobalizationHelper.MaxMilliSeconds || ticks < InternalGlobalizationHelper.MinMilliSeconds)
599 {
600 result = 0;
601 return false;
602 }
603
604 result = ticks * TimeSpan.TicksPerMillisecond + fraction._num;
605 if (positive && result < 0)
606 {
607 result = 0;
608 return false;
609 }
610
611 return true;
612 }
613
614 internal static TimeSpan Parse(ReadOnlySpan<char> input, IFormatProvider? formatProvider)
615 {
616 var parseResult = new TimeSpanResult(throwOnFailure: true, originalTimeSpanString: input);
617 bool success = TryParseTimeSpan(input, TimeSpanStandardStyles.Any, formatProvider, ref parseResult);
618 Debug.Assert(success, "Should have thrown on failure");
619 return parseResult.parsedTimeSpan;
620 }
621
622 internal static bool TryParse(ReadOnlySpan<char> input, IFormatProvider? formatProvider, out TimeSpan result)
623 {
624 var parseResult = new TimeSpanResult(throwOnFailure: false, originalTimeSpanString: input);
625
626 if (TryParseTimeSpan(input, TimeSpanStandardStyles.Any, formatProvider, ref parseResult))
627 {
628 result = parseResult.parsedTimeSpan;
629 return true;
630 }
631
632 result = default;
633 return false;
634 }
635
636 internal static TimeSpan ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, TimeSpanStyles styles)
637 {
638 var parseResult = new TimeSpanResult(throwOnFailure: true, originalTimeSpanString: input);
639 bool success = TryParseExactTimeSpan(input, format, formatProvider, styles, ref parseResult);
640 Debug.Assert(success, "Should have thrown on failure");
641 return parseResult.parsedTimeSpan;
642 }
643
644 internal static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, TimeSpanStyles styles, out TimeSpan result)
645 {
646 var parseResult = new TimeSpanResult(throwOnFailure: false, originalTimeSpanString: input);
647
648 if (TryParseExactTimeSpan(input, format, formatProvider, styles, ref parseResult))
649 {
650 result = parseResult.parsedTimeSpan;
651 return true;
652 }
653
654 result = default;
655 return false;
656 }
657
658 internal static TimeSpan ParseExactMultiple(ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, TimeSpanStyles styles)
659 {
660 var parseResult = new TimeSpanResult(throwOnFailure: true, originalTimeSpanString: input);
661 bool success = TryParseExactMultipleTimeSpan(input, formats, formatProvider, styles, ref parseResult);
662 Debug.Assert(success, "Should have thrown on failure");
663 return parseResult.parsedTimeSpan;
664 }
665
666 internal static bool TryParseExactMultiple(ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, TimeSpanStyles styles, out TimeSpan result)
667 {
668 var parseResult = new TimeSpanResult(throwOnFailure: false, originalTimeSpanString: input);
669
670 if (TryParseExactMultipleTimeSpan(input, formats, formatProvider, styles, ref parseResult))
671 {
672 result = parseResult.parsedTimeSpan;
673 return true;
674 }
675
676 result = default;
677 return false;
678 }
679
680 /// <summary>Common private Parse method called by both Parse and TryParse.</summary>
681 private static bool TryParseTimeSpan(ReadOnlySpan<char> input, TimeSpanStandardStyles style, IFormatProvider? formatProvider, ref TimeSpanResult result)
682 {
683 input = input.Trim();
684 if (input.IsEmpty)
685 {
686 return result.SetBadTimeSpanFailure();
687 }
688
689 var tokenizer = new TimeSpanTokenizer(input);
690
691 var raw = new TimeSpanRawInfo();
692 raw.Init(DateTimeFormatInfo.GetInstance(formatProvider));
693
694 TimeSpanToken tok = tokenizer.GetNextToken();
695
696 // The following loop will break out when we reach the end of the str or
697 // when we can determine that the input is invalid.
698 while (tok._ttt != TTT.End)
699 {
700 if (!raw.ProcessToken(ref tok, ref result))
701 {
702 return result.SetBadTimeSpanFailure();
703 }
704 tok = tokenizer.GetNextToken();
705 }
706 Debug.Assert(tokenizer.EOL);
707
708 if (!ProcessTerminalState(ref raw, style, ref result))
709 {
710 return result.SetBadTimeSpanFailure();
711 }
712
713 return true;
714 }
715
716 /// <summary>
717 /// Validate the terminal state of a standard format parse.
718 /// Sets result.parsedTimeSpan on success.
719 /// Calculates the resultant TimeSpan from the TimeSpanRawInfo.
720 /// </summary>
721 /// <remarks>
722 /// try => +InvariantPattern, -InvariantPattern, +LocalizedPattern, -LocalizedPattern
723 /// 1) Verify Start matches
724 /// 2) Verify End matches
725 /// 3) 1 number => d
726 /// 2 numbers => h:m
727 /// 3 numbers => h:m:s | d.h:m | h:m:.f
728 /// 4 numbers => h:m:s.f | d.h:m:s | d.h:m:.f
729 /// 5 numbers => d.h:m:s.f
730 /// </remarks>
731 private static bool ProcessTerminalState(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
732 {
733 if (raw._lastSeenTTT == TTT.Num)
734 {
735 TimeSpanToken tok = new TimeSpanToken();
736 tok._ttt = TTT.Sep;
737 if (!raw.ProcessToken(ref tok, ref result))
738 {
739 return result.SetBadTimeSpanFailure();
740 }
741 }
742
743 switch (raw._numCount)
744 {
745 case 1: return ProcessTerminal_D(ref raw, style, ref result);
746 case 2: return ProcessTerminal_HM(ref raw, style, ref result);
747 case 3: return ProcessTerminal_HM_S_D(ref raw, style, ref result);
748 case 4: return ProcessTerminal_HMS_F_D(ref raw, style, ref result);
749 case 5: return ProcessTerminal_DHMSF(ref raw, style, ref result);
750 default: return result.SetBadTimeSpanFailure();
751 }
752 }
753
754 /// <summary>Validate the 5-number "Days.Hours:Minutes:Seconds.Fraction" terminal case.</summary>
755 private static bool ProcessTerminal_DHMSF(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
756 {
757 if (raw._sepCount != 6)
758 {
759 return result.SetBadTimeSpanFailure();
760 }
761 Debug.Assert(raw._numCount == 5);
762
763 bool inv = (style & TimeSpanStandardStyles.Invariant) != 0;
764 bool loc = (style & TimeSpanStandardStyles.Localized) != 0;
765 bool positive = false;
766 bool match = false;
767
768 if (inv)
769 {
770 if (raw.FullMatch(raw.PositiveInvariant))
771 {
772 match = true;
773 positive = true;
774 }
775 if (!match && raw.FullMatch(raw.NegativeInvariant))
776 {
777 match = true;
778 positive = false;
779 }
780 }
781
782 if (loc)
783 {
784 if (!match && raw.FullMatch(raw.PositiveLocalized))
785 {
786 match = true;
787 positive = true;
788 }
789 if (!match && raw.FullMatch(raw.NegativeLocalized))
790 {
791 match = true;
792 positive = false;
793 }
794 }
795
796 if (match)
797 {
798 long ticks;
799
800 if (!TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, raw._numbers4, out ticks))
801 {
802 return result.SetOverflowFailure();
803 }
804
805 if (!positive)
806 {
807 ticks = -ticks;
808 if (ticks > 0)
809 {
810 return result.SetOverflowFailure();
811 }
812 }
813
814 result.parsedTimeSpan = new TimeSpan(ticks);
815 return true;
816 }
817
818 return result.SetBadTimeSpanFailure();
819 }
820
821
822 /// <summary>
823 /// Validate the ambiguous 4-number "Hours:Minutes:Seconds.Fraction", "Days.Hours:Minutes:Seconds",
824 /// or "Days.Hours:Minutes:.Fraction" terminal case.
825 /// </summary>
826 private static bool ProcessTerminal_HMS_F_D(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
827 {
828 if (raw._sepCount != 5 || (style & TimeSpanStandardStyles.RequireFull) != 0)
829 {
830 return result.SetBadTimeSpanFailure();
831 }
832 Debug.Assert(raw._numCount == 4);
833
834 bool inv = ((style & TimeSpanStandardStyles.Invariant) != 0);
835 bool loc = ((style & TimeSpanStandardStyles.Localized) != 0);
836
837 long ticks = 0;
838 bool positive = false, match = false, overflow = false;
839 var zero = new TimeSpanToken(0);
840
841 if (inv)
842 {
843 if (raw.FullHMSFMatch(raw.PositiveInvariant))
844 {
845 positive = true;
846 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out ticks);
847 overflow = overflow || !match;
848 }
849
850 if (!match && raw.FullDHMSMatch(raw.PositiveInvariant))
851 {
852 positive = true;
853 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, zero, out ticks);
854 overflow = overflow || !match;
855 }
856
857 if (!match && raw.FullAppCompatMatch(raw.PositiveInvariant))
858 {
859 positive = true;
860 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, raw._numbers3, out ticks);
861 overflow = overflow || !match;
862 }
863
864 if (!match && raw.FullHMSFMatch(raw.NegativeInvariant))
865 {
866 positive = false;
867 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out ticks);
868 overflow = overflow || !match;
869 }
870
871 if (!match && raw.FullDHMSMatch(raw.NegativeInvariant))
872 {
873 positive = false;
874 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, zero, out ticks);
875 overflow = overflow || !match;
876 }
877
878 if (!match && raw.FullAppCompatMatch(raw.NegativeInvariant))
879 {
880 positive = false;
881 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, raw._numbers3, out ticks);
882 overflow = overflow || !match;
883 }
884 }
885
886 if (loc)
887 {
888 if (!match && raw.FullHMSFMatch(raw.PositiveLocalized))
889 {
890 positive = true;
891 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out ticks);
892 overflow = overflow || !match;
893 }
894
895 if (!match && raw.FullDHMSMatch(raw.PositiveLocalized))
896 {
897 positive = true;
898 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, zero, out ticks);
899 overflow = overflow || !match;
900 }
901
902 if (!match && raw.FullAppCompatMatch(raw.PositiveLocalized))
903 {
904 positive = true;
905 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, raw._numbers3, out ticks);
906 overflow = overflow || !match;
907 }
908
909 if (!match && raw.FullHMSFMatch(raw.NegativeLocalized))
910 {
911 positive = false;
912 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out ticks);
913 overflow = overflow || !match;
914 }
915
916 if (!match && raw.FullDHMSMatch(raw.NegativeLocalized))
917 {
918 positive = false;
919 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, zero, out ticks);
920 overflow = overflow || !match;
921 }
922
923 if (!match && raw.FullAppCompatMatch(raw.NegativeLocalized))
924 {
925 positive = false;
926 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, raw._numbers3, out ticks);
927 overflow = overflow || !match;
928 }
929 }
930
931 if (match)
932 {
933 if (!positive)
934 {
935 ticks = -ticks;
936 if (ticks > 0)
937 {
938 return result.SetOverflowFailure();
939 }
940 }
941
942 result.parsedTimeSpan = new TimeSpan(ticks);
943 return true;
944 }
945
946 return overflow ?
947 result.SetOverflowFailure() : // we found at least one literal pattern match but the numbers just didn't fit
948 result.SetBadTimeSpanFailure(); // we couldn't find a thing
949 }
950
951 /// <summary>Validate the ambiguous 3-number "Hours:Minutes:Seconds", "Days.Hours:Minutes", or "Hours:Minutes:.Fraction" terminal case.</summary>
952 private static bool ProcessTerminal_HM_S_D(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
953 {
954 if (raw._sepCount != 4 || (style & TimeSpanStandardStyles.RequireFull) != 0)
955 {
956 return result.SetBadTimeSpanFailure();
957 }
958 Debug.Assert(raw._numCount == 3);
959
960 bool inv = ((style & TimeSpanStandardStyles.Invariant) != 0);
961 bool loc = ((style & TimeSpanStandardStyles.Localized) != 0);
962
963 bool positive = false, match = false, overflow = false;
964 var zero = new TimeSpanToken(0);
965 long ticks = 0;
966
967 if (inv)
968 {
969 if (raw.FullHMSMatch(raw.PositiveInvariant))
970 {
971 positive = true;
972 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, zero, out ticks);
973 overflow = overflow || !match;
974 }
975
976 if (!match && raw.FullDHMMatch(raw.PositiveInvariant))
977 {
978 positive = true;
979 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, zero, out ticks);
980 overflow = overflow || !match;
981 }
982
983 if (!match && raw.PartialAppCompatMatch(raw.PositiveInvariant))
984 {
985 positive = true;
986 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, zero, raw._numbers2, out ticks);
987 overflow = overflow || !match;
988 }
989
990 if (!match && raw.FullHMSMatch(raw.NegativeInvariant))
991 {
992 positive = false;
993 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, zero, out ticks);
994 overflow = overflow || !match;
995 }
996
997 if (!match && raw.FullDHMMatch(raw.NegativeInvariant))
998 {
999 positive = false;
1000 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, zero, out ticks);
1001 overflow = overflow || !match;
1002 }
1003
1004 if (!match && raw.PartialAppCompatMatch(raw.NegativeInvariant))
1005 {
1006 positive = false;
1007 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, zero, raw._numbers2, out ticks);
1008 overflow = overflow || !match;
1009 }
1010 }
1011
1012 if (loc)
1013 {
1014 if (!match && raw.FullHMSMatch(raw.PositiveLocalized))
1015 {
1016 positive = true;
1017 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, zero, out ticks);
1018 overflow = overflow || !match;
1019 }
1020
1021 if (!match && raw.FullDHMMatch(raw.PositiveLocalized))
1022 {
1023 positive = true;
1024 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, zero, out ticks);
1025 overflow = overflow || !match;
1026 }
1027
1028 if (!match && raw.PartialAppCompatMatch(raw.PositiveLocalized))
1029 {
1030 positive = true;
1031 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, zero, raw._numbers2, out ticks);
1032 overflow = overflow || !match;
1033 }
1034
1035 if (!match && raw.FullHMSMatch(raw.NegativeLocalized))
1036 {
1037 positive = false;
1038 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, raw._numbers2, zero, out ticks);
1039 overflow = overflow || !match;
1040 }
1041
1042 if (!match && raw.FullDHMMatch(raw.NegativeLocalized))
1043 {
1044 positive = false;
1045 match = TryTimeToTicks(positive, raw._numbers0, raw._numbers1, raw._numbers2, zero, zero, out ticks);
1046 overflow = overflow || !match;
1047 }
1048
1049 if (!match && raw.PartialAppCompatMatch(raw.NegativeLocalized))
1050 {
1051 positive = false;
1052 match = TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, zero, raw._numbers2, out ticks);
1053 overflow = overflow || !match;
1054 }
1055 }
1056
1057 if (match)
1058 {
1059 if (!positive)
1060 {
1061 ticks = -ticks;
1062 if (ticks > 0)
1063 {
1064 return result.SetOverflowFailure();
1065 }
1066 }
1067
1068 result.parsedTimeSpan = new TimeSpan(ticks);
1069 return true;
1070 }
1071
1072 return overflow ?
1073 result.SetOverflowFailure() : // we found at least one literal pattern match but the numbers just didn't fit
1074 result.SetBadTimeSpanFailure(); // we couldn't find a thing
1075 }
1076
1077 /// <summary>Validate the 2-number "Hours:Minutes" terminal case.</summary>
1078 private static bool ProcessTerminal_HM(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
1079 {
1080 if (raw._sepCount != 3 || (style & TimeSpanStandardStyles.RequireFull) != 0)
1081 {
1082 return result.SetBadTimeSpanFailure();
1083 }
1084 Debug.Assert(raw._numCount == 2);
1085
1086 bool inv = ((style & TimeSpanStandardStyles.Invariant) != 0);
1087 bool loc = ((style & TimeSpanStandardStyles.Localized) != 0);
1088
1089 bool positive = false, match = false;
1090
1091 if (inv)
1092 {
1093 if (raw.FullHMMatch(raw.PositiveInvariant))
1094 {
1095 match = true;
1096 positive = true;
1097 }
1098
1099 if (!match && raw.FullHMMatch(raw.NegativeInvariant))
1100 {
1101 match = true;
1102 positive = false;
1103 }
1104 }
1105
1106 if (loc)
1107 {
1108 if (!match && raw.FullHMMatch(raw.PositiveLocalized))
1109 {
1110 match = true;
1111 positive = true;
1112 }
1113
1114 if (!match && raw.FullHMMatch(raw.NegativeLocalized))
1115 {
1116 match = true;
1117 positive = false;
1118 }
1119 }
1120
1121 if (match)
1122 {
1123 long ticks = 0;
1124 var zero = new TimeSpanToken(0);
1125
1126 if (!TryTimeToTicks(positive, zero, raw._numbers0, raw._numbers1, zero, zero, out ticks))
1127 {
1128 return result.SetOverflowFailure();
1129 }
1130
1131 if (!positive)
1132 {
1133 ticks = -ticks;
1134 if (ticks > 0)
1135 {
1136 return result.SetOverflowFailure();
1137 }
1138 }
1139
1140 result.parsedTimeSpan = new TimeSpan(ticks);
1141 return true;
1142 }
1143
1144 return result.SetBadTimeSpanFailure();
1145 }
1146
1147 /// <summary>Validate the 1-number "Days" terminal case.</summary>
1148 private static bool ProcessTerminal_D(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
1149 {
1150 if (raw._sepCount != 2 || (style & TimeSpanStandardStyles.RequireFull) != 0)
1151 {
1152 return result.SetBadTimeSpanFailure();
1153 }
1154 Debug.Assert(raw._numCount == 1);
1155
1156 bool inv = ((style & TimeSpanStandardStyles.Invariant) != 0);
1157 bool loc = ((style & TimeSpanStandardStyles.Localized) != 0);
1158
1159 bool positive = false, match = false;
1160
1161 if (inv)
1162 {
1163 if (raw.FullDMatch(raw.PositiveInvariant))
1164 {
1165 match = true;
1166 positive = true;
1167 }
1168
1169 if (!match && raw.FullDMatch(raw.NegativeInvariant))
1170 {
1171 match = true;
1172 positive = false;
1173 }
1174 }
1175
1176 if (loc)
1177 {
1178 if (!match && raw.FullDMatch(raw.PositiveLocalized))
1179 {
1180 match = true;
1181 positive = true;
1182 }
1183
1184 if (!match && raw.FullDMatch(raw.NegativeLocalized))
1185 {
1186 match = true;
1187 positive = false;
1188 }
1189 }
1190
1191 if (match)
1192 {
1193 long ticks = 0;
1194 var zero = new TimeSpanToken(0);
1195
1196 if (!TryTimeToTicks(positive, raw._numbers0, zero, zero, zero, zero, out ticks))
1197 {
1198 return result.SetOverflowFailure();
1199 }
1200
1201 if (!positive)
1202 {
1203 ticks = -ticks;
1204 if (ticks > 0)
1205 {
1206 return result.SetOverflowFailure();
1207 }
1208 }
1209
1210 result.parsedTimeSpan = new TimeSpan(ticks);
1211 return true;
1212 }
1213
1214 return result.SetBadTimeSpanFailure();
1215 }
1216
1217 /// <summary>Common private ParseExact method called by both ParseExact and TryParseExact.</summary>
1218 private static bool TryParseExactTimeSpan(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, TimeSpanStyles styles, ref TimeSpanResult result)
1219 {
1220 if (format.Length == 0)
1221 {
1222 return result.SetBadFormatSpecifierFailure();
1223 }
1224
1225 if (format.Length == 1)
1226 {
1227 switch (format[0])
1228 {
1229 case 'c':
1230 case 't':
1231 case 'T':
1232 return TryParseTimeSpanConstant(input, ref result); // fast path for legacy style TimeSpan formats.
1233
1234 case 'g':
1235 return TryParseTimeSpan(input, TimeSpanStandardStyles.Localized, formatProvider, ref result);
1236
1237 case 'G':
1238 return TryParseTimeSpan(input, TimeSpanStandardStyles.Localized | TimeSpanStandardStyles.RequireFull, formatProvider, ref result);
1239
1240 default:
1241 return result.SetBadFormatSpecifierFailure(format[0]);
1242 }
1243 }
1244
1245 return TryParseByFormat(input, format, styles, ref result);
1246 }
1247
1248 /// <summary>Parse the TimeSpan instance using the specified format. Used by TryParseExactTimeSpan.</summary>
1249 private static bool TryParseByFormat(ReadOnlySpan<char> input, ReadOnlySpan<char> format, TimeSpanStyles styles, ref TimeSpanResult result)
1250 {
1251 bool seenDD = false; // already processed days?
1252 bool seenHH = false; // already processed hours?
1253 bool seenMM = false; // already processed minutes?
1254 bool seenSS = false; // already processed seconds?
1255 bool seenFF = false; // already processed fraction?
1256
1257 int dd = 0; // parsed days
1258 int hh = 0; // parsed hours
1259 int mm = 0; // parsed minutes
1260 int ss = 0; // parsed seconds
1261 int leadingZeroes = 0; // number of leading zeroes in the parsed fraction
1262 int ff = 0; // parsed fraction
1263 int i = 0; // format string position
1264 int tokenLen = 0; // length of current format token, used to update index 'i'
1265
1266 var tokenizer = new TimeSpanTokenizer(input, -1);
1267
1268 while (i < format.Length)
1269 {
1270 char ch = format[i];
1271 int nextFormatChar;
1272 switch (ch)
1273 {
1274 case 'h':
1275 tokenLen = DateTimeFormat.ParseRepeatPattern(format, i, ch);
1276 if (tokenLen > 2 || seenHH || !ParseExactDigits(ref tokenizer, tokenLen, out hh))
1277 {
1278 return result.SetInvalidStringFailure();
1279 }
1280 seenHH = true;
1281 break;
1282
1283 case 'm':
1284 tokenLen = DateTimeFormat.ParseRepeatPattern(format, i, ch);
1285 if (tokenLen > 2 || seenMM || !ParseExactDigits(ref tokenizer, tokenLen, out mm))
1286 {
1287 return result.SetInvalidStringFailure();
1288 }
1289 seenMM = true;
1290 break;
1291
1292 case 's':
1293 tokenLen = DateTimeFormat.ParseRepeatPattern(format, i, ch);
1294 if (tokenLen > 2 || seenSS || !ParseExactDigits(ref tokenizer, tokenLen, out ss))
1295 {
1296 return result.SetInvalidStringFailure();
1297 }
1298 seenSS = true;
1299 break;
1300
1301 case 'f':
1302 tokenLen = DateTimeFormat.ParseRepeatPattern(format, i, ch);
1303 if (tokenLen > DateTimeFormat.MaxSecondsFractionDigits || seenFF || !ParseExactDigits(ref tokenizer, tokenLen, tokenLen, out leadingZeroes, out ff))
1304 {
1305 return result.SetInvalidStringFailure();
1306 }
1307 seenFF = true;
1308 break;
1309
1310 case 'F':
1311 tokenLen = DateTimeFormat.ParseRepeatPattern(format, i, ch);
1312 if (tokenLen > DateTimeFormat.MaxSecondsFractionDigits || seenFF)
1313 {
1314 return result.SetInvalidStringFailure();
1315 }
1316 ParseExactDigits(ref tokenizer, tokenLen, tokenLen, out leadingZeroes, out ff);
1317 seenFF = true;
1318 break;
1319
1320 case 'd':
1321 tokenLen = DateTimeFormat.ParseRepeatPattern(format, i, ch);
1322 int tmp = 0;
1323 if (tokenLen > 8 || seenDD || !ParseExactDigits(ref tokenizer, (tokenLen < 2) ? 1 : tokenLen, (tokenLen < 2) ? 8 : tokenLen, out tmp, out dd))
1324 {
1325 return result.SetInvalidStringFailure();
1326 }
1327 seenDD = true;
1328 break;
1329
1330 case '\'':
1331 case '\"':
1332 StringBuilder enquotedString = StringBuilderCache.Acquire();
1333 if (!DateTimeParse.TryParseQuoteString(format, i, enquotedString, out tokenLen))
1334 {
1335 StringBuilderCache.Release(enquotedString);
1336 return result.SetBadQuoteFailure(ch);
1337 }
1338 if (!ParseExactLiteral(ref tokenizer, enquotedString))
1339 {
1340 StringBuilderCache.Release(enquotedString);
1341 return result.SetInvalidStringFailure();
1342 }
1343 StringBuilderCache.Release(enquotedString);
1344 break;
1345
1346 case '%':
1347 // Optional format character.
1348 // For example, format string "%d" will print day
1349 // Most of the cases, "%" can be ignored.
1350 nextFormatChar = DateTimeFormat.ParseNextChar(format, i);
1351
1352 // nextFormatChar will be -1 if we already reach the end of the format string.
1353 // Besides, we will not allow "%%" appear in the pattern.
1354 if (nextFormatChar >= 0 && nextFormatChar != '%')
1355 {
1356 tokenLen = 1; // skip the '%' and process the format character
1357 break;
1358 }
1359 else
1360 {
1361 // This means that '%' is at the end of the format string or
1362 // "%%" appears in the format string.
1363 return result.SetInvalidStringFailure();
1364 }
1365
1366 case '\\':
1367 // Escaped character. Can be used to insert character into the format string.
1368 // For example, "\d" will insert the character 'd' into the string.
1369 //
1370 nextFormatChar = DateTimeFormat.ParseNextChar(format, i);
1371 if (nextFormatChar >= 0 && tokenizer.NextChar == (char)nextFormatChar)
1372 {
1373 tokenLen = 2;
1374 }
1375 else
1376 {
1377 // This means that '\' is at the end of the format string or the literal match failed.
1378 return result.SetInvalidStringFailure();
1379 }
1380 break;
1381
1382 default:
1383 return result.SetInvalidStringFailure();
1384 }
1385
1386 i += tokenLen;
1387 }
1388
1389
1390 if (!tokenizer.EOL)
1391 {
1392 // the custom format didn't consume the entire input
1393 return result.SetBadTimeSpanFailure();
1394 }
1395
1396 bool positive = (styles & TimeSpanStyles.AssumeNegative) == 0;
1397 if (TryTimeToTicks(positive, new TimeSpanToken(dd),
1398 new TimeSpanToken(hh),
1399 new TimeSpanToken(mm),
1400 new TimeSpanToken(ss),
1401 new TimeSpanToken(ff, leadingZeroes),
1402 out long ticks))
1403 {
1404 if (!positive)
1405 {
1406 ticks = -ticks;
1407 }
1408
1409 result.parsedTimeSpan = new TimeSpan(ticks);
1410 return true;
1411 }
1412 else
1413 {
1414 return result.SetOverflowFailure();
1415 }
1416 }
1417
1418 private static bool ParseExactDigits(ref TimeSpanTokenizer tokenizer, int minDigitLength, out int result)
1419 {
1420 result = 0;
1421 int zeroes = 0;
1422 int maxDigitLength = (minDigitLength == 1) ? 2 : minDigitLength;
1423 return ParseExactDigits(ref tokenizer, minDigitLength, maxDigitLength, out zeroes, out result);
1424 }
1425
1426 private static bool ParseExactDigits(ref TimeSpanTokenizer tokenizer, int minDigitLength, int maxDigitLength, out int zeroes, out int result)
1427 {
1428 int tmpResult = 0, tmpZeroes = 0;
1429
1430 int tokenLength = 0;
1431 while (tokenLength < maxDigitLength)
1432 {
1433 char ch = tokenizer.NextChar;
1434 if (ch < '0' || ch > '9')
1435 {
1436 tokenizer.BackOne();
1437 break;
1438 }
1439
1440 tmpResult = tmpResult * 10 + (ch - '0');
1441 if (tmpResult == 0) tmpZeroes++;
1442 tokenLength++;
1443 }
1444
1445 zeroes = tmpZeroes;
1446 result = tmpResult;
1447 return tokenLength >= minDigitLength;
1448 }
1449
1450 private static bool ParseExactLiteral(ref TimeSpanTokenizer tokenizer, StringBuilder enquotedString)
1451 {
1452 for (int i = 0; i < enquotedString.Length; i++)
1453 {
1454 if (enquotedString[i] != tokenizer.NextChar)
1455 {
1456 return false;
1457 }
1458 }
1459
1460 return true;
1461 }
1462
1463 /// <summary>
1464 /// Parses the "c" (constant) format. This code is 100% identical to the non-globalized v1.0-v3.5 TimeSpan.Parse() routine
1465 /// and exists for performance/appcompat with legacy callers who cannot move onto the globalized Parse overloads.
1466 /// </summary>
1467 private static bool TryParseTimeSpanConstant(ReadOnlySpan<char> input, ref TimeSpanResult result) =>
1468 new StringParser().TryParse(input, ref result);
1469
1470 private ref struct StringParser
1471 {
1472 private ReadOnlySpan<char> _str;
1473 private char _ch;
1474 private int _pos;
1475 private int _len;
1476
1477 internal void NextChar()
1478 {
1479 if (_pos < _len)
1480 {
1481 _pos++;
1482 }
1483
1484 _ch = _pos < _len ?
1485 _str[_pos] :
1486 (char)0;
1487 }
1488
1489 internal char NextNonDigit()
1490 {
1491 int i = _pos;
1492 while (i < _len)
1493 {
1494 char ch = _str[i];
1495 if (ch < '0' || ch > '9') return ch;
1496 i++;
1497 }
1498
1499 return (char)0;
1500 }
1501
1502 internal bool TryParse(ReadOnlySpan<char> input, ref TimeSpanResult result)
1503 {
1504 result.parsedTimeSpan = default;
1505
1506 _str = input;
1507 _len = input.Length;
1508 _pos = -1;
1509 NextChar();
1510 SkipBlanks();
1511
1512 bool negative = false;
1513 if (_ch == '-')
1514 {
1515 negative = true;
1516 NextChar();
1517 }
1518
1519 long time;
1520 if (NextNonDigit() == ':')
1521 {
1522 if (!ParseTime(out time, ref result))
1523 {
1524 return false;
1525 };
1526 }
1527 else
1528 {
1529 int days;
1530 if (!ParseInt((int)(0x7FFFFFFFFFFFFFFFL / TimeSpan.TicksPerDay), out days, ref result))
1531 {
1532 return false;
1533 }
1534
1535 time = days * TimeSpan.TicksPerDay;
1536
1537 if (_ch == '.')
1538 {
1539 NextChar();
1540 long remainingTime;
1541 if (!ParseTime(out remainingTime, ref result))
1542 {
1543 return false;
1544 };
1545 time += remainingTime;
1546 }
1547 }
1548
1549 if (negative)
1550 {
1551 time = -time;
1552 // Allow -0 as well
1553 if (time > 0)
1554 {
1555 return result.SetOverflowFailure();
1556 }
1557 }
1558 else
1559 {
1560 if (time < 0)
1561 {
1562 return result.SetOverflowFailure();
1563 }
1564 }
1565
1566 SkipBlanks();
1567
1568 if (_pos < _len)
1569 {
1570 return result.SetBadTimeSpanFailure();
1571 }
1572
1573 result.parsedTimeSpan = new TimeSpan(time);
1574 return true;
1575 }
1576
1577 internal bool ParseInt(int max, out int i, ref TimeSpanResult result)
1578 {
1579 i = 0;
1580 int p = _pos;
1581 while (_ch >= '0' && _ch <= '9')
1582 {
1583 if ((i & 0xF0000000) != 0)
1584 {
1585 return result.SetOverflowFailure();
1586 }
1587
1588 i = i * 10 + _ch - '0';
1589 if (i < 0)
1590 {
1591 return result.SetOverflowFailure();
1592 }
1593
1594 NextChar();
1595 }
1596
1597 if (p == _pos)
1598 {
1599 return result.SetBadTimeSpanFailure();
1600 }
1601
1602 if (i > max)
1603 {
1604 return result.SetOverflowFailure();
1605 }
1606
1607 return true;
1608 }
1609
1610 internal bool ParseTime(out long time, ref TimeSpanResult result)
1611 {
1612 time = 0;
1613 int unit;
1614
1615 if (!ParseInt(23, out unit, ref result))
1616 {
1617 return false;
1618 }
1619
1620 time = unit * TimeSpan.TicksPerHour;
1621 if (_ch != ':')
1622 {
1623 return result.SetBadTimeSpanFailure();
1624 }
1625
1626 NextChar();
1627
1628 if (!ParseInt(59, out unit, ref result))
1629 {
1630 return false;
1631 }
1632
1633 time += unit * TimeSpan.TicksPerMinute;
1634
1635 if (_ch == ':')
1636 {
1637 NextChar();
1638
1639 // allow seconds with the leading zero
1640 if (_ch != '.')
1641 {
1642 if (!ParseInt(59, out unit, ref result))
1643 {
1644 return false;
1645 }
1646 time += unit * TimeSpan.TicksPerSecond;
1647 }
1648
1649 if (_ch == '.')
1650 {
1651 NextChar();
1652 int f = (int)TimeSpan.TicksPerSecond;
1653 while (f > 1 && _ch >= '0' && _ch <= '9')
1654 {
1655 f /= 10;
1656 time += (_ch - '0') * f;
1657 NextChar();
1658 }
1659 }
1660 }
1661
1662 return true;
1663 }
1664
1665 internal void SkipBlanks()
1666 {
1667 while (_ch == ' ' || _ch == '\t') NextChar();
1668 }
1669 }
1670
1671 /// <summary>Common private ParseExactMultiple method called by both ParseExactMultiple and TryParseExactMultiple.</summary>
1672 private static bool TryParseExactMultipleTimeSpan(ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, TimeSpanStyles styles, ref TimeSpanResult result)
1673 {
1674 if (formats == null)
1675 {
1676 return result.SetArgumentNullFailure(nameof(formats));
1677 }
1678
1679 if (input.Length == 0)
1680 {
1681 return result.SetBadTimeSpanFailure();
1682 }
1683
1684 if (formats.Length == 0)
1685 {
1686 return result.SetNoFormatSpecifierFailure();
1687 }
1688
1689 // Do a loop through the provided formats and see if we can parse succesfully in
1690 // one of the formats.
1691 for (int i = 0; i < formats.Length; i++)
1692 {
1693 if (formats[i] == null || formats[i].Length == 0)
1694 {
1695 return result.SetBadFormatSpecifierFailure();
1696 }
1697
1698 // Create a new non-throwing result each time to ensure the runs are independent.
1699 TimeSpanResult innerResult = new TimeSpanResult(throwOnFailure: false, originalTimeSpanString: input);
1700
1701 if (TryParseExactTimeSpan(input, formats[i], formatProvider, styles, ref innerResult))
1702 {
1703 result.parsedTimeSpan = innerResult.parsedTimeSpan;
1704 return true;
1705 }
1706 }
1707
1708 return result.SetBadTimeSpanFailure();
1709 }
1710 }
1711 }
Mirror of the official Mono project git repository