System.__DTString.GetRegularToken C# (CSharp) Method

        internal void GetRegularToken(out TokenType tokenType, out int tokenValue, DateTimeFormatInfo dtfi) {
            tokenValue = 0;
            if (Index >= len) {
                tokenType = TokenType.EndOfString;
                return;
            }

            tokenType = TokenType.UnknownToken;

Start:
            if (DateTimeParse.IsDigit(m_current)) {
                // This is a digit.
                tokenValue = m_current - '0';
                int value;
                int start = Index;

                //
                // Collect other digits.
                //
                while (++Index < len)
                {
                    m_current = Value[Index];
                    value = m_current - '0';
                    if (value >= 0 && value <= 9) {
                        tokenValue = tokenValue * 10 + value;
                    } else {
                        break;
                    }
                }
                if (Index - start > DateTimeParse.MaxDateTimeNumberDigits) {
                    tokenType = TokenType.NumberToken;
                    tokenValue = -1;
                } else if (Index - start < 3) {
                    tokenType = TokenType.NumberToken;
                } else {
                    // If there are more than 3 digits, assume that it's a year value.
                    tokenType = TokenType.YearNumberToken;
                }
                if (m_checkDigitToken)
                {
                    int save = Index;
                    char saveCh = m_current;
                    // Re-scan using the staring Index to see if this is a token.
                    Index = start;  // To include the first digit.
                    m_current = Value[Index];
                    TokenType tempType;
                    int tempValue;
                    // This DTFI has tokens starting with digits.
                    // E.g. mn-MN has month name like "\x0031\x00a0\x0434\x04af\x0433\x044d\x044d\x0440\x00a0\x0441\x0430\x0440"
                    if (dtfi.Tokenize(TokenType.RegularTokenMask, out tempType, out tempValue, ref this))
                    {
                        tokenType = tempType;
                        tokenValue = tempValue;
                        // This is a token, so the Index has been advanced propertly in DTFI.Tokenizer().
                    } else
                    {
                        // Use the number token value.
                        // Restore the index.
                        Index = save;
                        m_current = saveCh;
                    }
                    
                } 
                
            } else if (Char.IsWhiteSpace( m_current)) {
                // Just skip to the next character.
                while (++Index < len) {
                    m_current = Value[Index];
                    if (!(Char.IsWhiteSpace(m_current))) {
                        goto Start;
                    }
                }
                // We have reached the end of string.
                tokenType = TokenType.EndOfString;
            } else {
                dtfi.Tokenize(TokenType.RegularTokenMask, out tokenType, out tokenValue, ref this);
            }
        }

		private static bool Lex(DateTimeParse.DS dps, ref __DTString str, ref DateTimeToken dtok, ref DateTimeRawInfo raw, ref DateTimeResult result, ref DateTimeFormatInfo dtfi)
		{
			dtok.dtt = DateTimeParse.DTT.Unk;
			TokenType tokenType;
			int num;
			str.GetRegularToken(out tokenType, out num, dtfi);
			switch (tokenType)
			{
				case TokenType.NumberToken:
				case TokenType.YearNumberToken:
				{
					if (raw.numCount == 3 || num == -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					if (dps == DateTimeParse.DS.T_NNt && str.Index < str.len - 1)
					{
						char c = str.Value[str.Index];
						if (c == '.')
						{
							DateTimeParse.ParseFraction(ref str, out raw.fraction);
						}
					}
					if ((dps == DateTimeParse.DS.T_NNt || dps == DateTimeParse.DS.T_Nt) && str.Index < str.len - 1 && !DateTimeParse.HandleTimeZone(ref str, ref result))
					{
						return false;
					}
					dtok.num = num;
					if (tokenType != TokenType.YearNumberToken)
					{
						int index;
						char current;
						TokenType separatorToken;
						TokenType tokenType2 = separatorToken = str.GetSeparatorToken(dtfi, out index, out current);
						if (separatorToken > TokenType.SEP_YearSuff)
						{
							if (separatorToken <= TokenType.SEP_HourSuff)
							{
								if (separatorToken == TokenType.SEP_MonthSuff || separatorToken == TokenType.SEP_DaySuff)
								{
									dtok.dtt = DateTimeParse.DTT.NumDatesuff;
									dtok.suffix = tokenType2;
									break;
								}
								if (separatorToken != TokenType.SEP_HourSuff)
								{
									goto IL_52A;
								}
							}
							else
							{
								if (separatorToken <= TokenType.SEP_SecondSuff)
								{
									if (separatorToken != TokenType.SEP_MinuteSuff && separatorToken != TokenType.SEP_SecondSuff)
									{
										goto IL_52A;
									}
								}
								else
								{
									if (separatorToken == TokenType.SEP_LocalTimeMark)
									{
										dtok.dtt = DateTimeParse.DTT.NumLocalTimeMark;
										raw.AddNumber(dtok.num);
										break;
									}
									if (separatorToken != TokenType.SEP_DateOrOffset)
									{
										goto IL_52A;
									}
									if (DateTimeParse.dateParsingStates[(int)dps][4] == DateTimeParse.DS.ERROR && DateTimeParse.dateParsingStates[(int)dps][3] > DateTimeParse.DS.ERROR)
									{
										str.Index = index;
										str.m_current = current;
										dtok.dtt = DateTimeParse.DTT.NumSpace;
									}
									else
									{
										dtok.dtt = DateTimeParse.DTT.NumDatesep;
									}
									raw.AddNumber(dtok.num);
									break;
								}
							}
							dtok.dtt = DateTimeParse.DTT.NumTimesuff;
							dtok.suffix = tokenType2;
							break;
						}
						if (separatorToken <= TokenType.SEP_Am)
						{
							if (separatorToken == TokenType.SEP_End)
							{
								dtok.dtt = DateTimeParse.DTT.NumEnd;
								raw.AddNumber(dtok.num);
								break;
							}
							if (separatorToken == TokenType.SEP_Space)
							{
								dtok.dtt = DateTimeParse.DTT.NumSpace;
								raw.AddNumber(dtok.num);
								break;
							}
							if (separatorToken != TokenType.SEP_Am)
							{
								goto IL_52A;
							}
						}
						else
						{
							if (separatorToken <= TokenType.SEP_Date)
							{
								if (separatorToken != TokenType.SEP_Pm)
								{
									if (separatorToken != TokenType.SEP_Date)
									{
										goto IL_52A;
									}
									dtok.dtt = DateTimeParse.DTT.NumDatesep;
									raw.AddNumber(dtok.num);
									break;
								}
							}
							else
							{
								if (separatorToken == TokenType.SEP_Time)
								{
									dtok.dtt = DateTimeParse.DTT.NumTimesep;
									raw.AddNumber(dtok.num);
									break;
								}
								if (separatorToken != TokenType.SEP_YearSuff)
								{
									goto IL_52A;
								}
								dtok.num = dtfi.Calendar.ToFourDigitYear(num);
								dtok.dtt = DateTimeParse.DTT.NumDatesuff;
								dtok.suffix = tokenType2;
								break;
							}
						}
						if (raw.timeMark != DateTimeParse.TM.NotSet)
						{
							result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
							break;
						}
						raw.timeMark = ((tokenType2 == TokenType.SEP_Am) ? DateTimeParse.TM.AM : DateTimeParse.TM.PM);
						dtok.dtt = DateTimeParse.DTT.NumAmpm;
						raw.AddNumber(dtok.num);
						if ((dps == DateTimeParse.DS.T_NNt || dps == DateTimeParse.DS.T_Nt) && !DateTimeParse.HandleTimeZone(ref str, ref result))
						{
							return false;
						}
						break;
						IL_52A:
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					if (raw.year == -1)
					{
						raw.year = num;
						int index;
						char current;
						TokenType separatorToken2;
						TokenType tokenType2 = separatorToken2 = str.GetSeparatorToken(dtfi, out index, out current);
						if (separatorToken2 > TokenType.SEP_YearSuff)
						{
							if (separatorToken2 <= TokenType.SEP_HourSuff)
							{
								if (separatorToken2 == TokenType.SEP_MonthSuff || separatorToken2 == TokenType.SEP_DaySuff)
								{
									goto IL_26A;
								}
								if (separatorToken2 != TokenType.SEP_HourSuff)
								{
									goto IL_28E;
								}
							}
							else
							{
								if (separatorToken2 != TokenType.SEP_MinuteSuff && separatorToken2 != TokenType.SEP_SecondSuff)
								{
									if (separatorToken2 != TokenType.SEP_DateOrOffset)
									{
										goto IL_28E;
									}
									if (DateTimeParse.dateParsingStates[(int)dps][13] == DateTimeParse.DS.ERROR && DateTimeParse.dateParsingStates[(int)dps][12] > DateTimeParse.DS.ERROR)
									{
										str.Index = index;
										str.m_current = current;
										dtok.dtt = DateTimeParse.DTT.YearSpace;
										return true;
									}
									dtok.dtt = DateTimeParse.DTT.YearDateSep;
									return true;
								}
							}
							dtok.dtt = DateTimeParse.DTT.NumTimesuff;
							dtok.suffix = tokenType2;
							return true;
						}
						if (separatorToken2 <= TokenType.SEP_Am)
						{
							if (separatorToken2 == TokenType.SEP_End)
							{
								dtok.dtt = DateTimeParse.DTT.YearEnd;
								return true;
							}
							if (separatorToken2 == TokenType.SEP_Space)
							{
								dtok.dtt = DateTimeParse.DTT.YearSpace;
								return true;
							}
							if (separatorToken2 != TokenType.SEP_Am)
							{
								goto IL_28E;
							}
						}
						else
						{
							if (separatorToken2 != TokenType.SEP_Pm)
							{
								if (separatorToken2 == TokenType.SEP_Date)
								{
									dtok.dtt = DateTimeParse.DTT.YearDateSep;
									return true;
								}
								if (separatorToken2 != TokenType.SEP_YearSuff)
								{
									goto IL_28E;
								}
								goto IL_26A;
							}
						}
						if (raw.timeMark == DateTimeParse.TM.NotSet)
						{
							raw.timeMark = ((tokenType2 == TokenType.SEP_Am) ? DateTimeParse.TM.AM : DateTimeParse.TM.PM);
							dtok.dtt = DateTimeParse.DTT.YearSpace;
							return true;
						}
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return true;
						IL_26A:
						dtok.dtt = DateTimeParse.DTT.NumDatesuff;
						dtok.suffix = tokenType2;
						return true;
						IL_28E:
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
					return false;
				}
				case TokenType.Am:
				case TokenType.Pm:
				{
					if (raw.timeMark != DateTimeParse.TM.NotSet)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					raw.timeMark = (DateTimeParse.TM)num;
					break;
				}
				case TokenType.MonthToken:
				{
					if (raw.month != -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					int index;
					char current;
					TokenType separatorToken3 = str.GetSeparatorToken(dtfi, out index, out current);
					if (separatorToken3 <= TokenType.SEP_Space)
					{
						if (separatorToken3 == TokenType.SEP_End)
						{
							dtok.dtt = DateTimeParse.DTT.MonthEnd;
							goto IL_786;
						}
						if (separatorToken3 == TokenType.SEP_Space)
						{
							dtok.dtt = DateTimeParse.DTT.MonthSpace;
							goto IL_786;
						}
					}
					else
					{
						if (separatorToken3 == TokenType.SEP_Date)
						{
							dtok.dtt = DateTimeParse.DTT.MonthDatesep;
							goto IL_786;
						}
						if (separatorToken3 == TokenType.SEP_DateOrOffset)
						{
							if (DateTimeParse.dateParsingStates[(int)dps][8] == DateTimeParse.DS.ERROR && DateTimeParse.dateParsingStates[(int)dps][7] > DateTimeParse.DS.ERROR)
							{
								str.Index = index;
								str.m_current = current;
								dtok.dtt = DateTimeParse.DTT.MonthSpace;
								goto IL_786;
							}
							dtok.dtt = DateTimeParse.DTT.MonthDatesep;
							goto IL_786;
						}
					}
					result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
					return false;
					IL_786:
					raw.month = num;
					break;
				}
				case TokenType.EndOfString:
				{
					dtok.dtt = DateTimeParse.DTT.End;
					break;
				}
				case TokenType.DayOfWeekToken:
				{
					if (raw.dayOfWeek != -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					raw.dayOfWeek = num;
					dtok.dtt = DateTimeParse.DTT.DayOfWeek;
					break;
				}
				case TokenType.TimeZoneToken:
				{
					if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					dtok.dtt = DateTimeParse.DTT.TimeZone;
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = new TimeSpan(0L);
					result.flags |= ParseFlags.TimeZoneUtc;
					break;
				}
				case TokenType.EraToken:
				{
					if (result.era == -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					result.era = num;
					dtok.dtt = DateTimeParse.DTT.Era;
					break;
				}
				case TokenType.UnknownToken:
				{
					if (char.IsLetter(str.m_current))
					{
						result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_UnknowDateTimeWord", str.Index);
						return false;
					}
					if (Environment.GetCompatibilityFlag(CompatibilityFlag.DateTimeParseIgnorePunctuation) && (result.flags & ParseFlags.CaptureOffset) == (ParseFlags)0)
					{
						str.GetNext();
						return true;
					}
					if ((str.m_current == '-' || str.m_current == '+') && (result.flags & ParseFlags.TimeZoneUsed) == (ParseFlags)0)
					{
						int index2 = str.Index;
						if (DateTimeParse.ParseTimeZone(ref str, ref result.timeZoneOffset))
						{
							result.flags |= ParseFlags.TimeZoneUsed;
							return true;
						}
						str.Index = index2;
					}
					if (DateTimeParse.VerifyValidPunctuation(ref str))
					{
						return true;
					}
					result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
					return false;
				}
				case TokenType.HebrewNumber:
				{
					int index;
					char current;
					if (num < 100)
					{
						dtok.num = num;
						raw.AddNumber(dtok.num);
						TokenType separatorToken4 = str.GetSeparatorToken(dtfi, out index, out current);
						if (separatorToken4 <= TokenType.SEP_Space)
						{
							if (separatorToken4 == TokenType.SEP_End)
							{
								dtok.dtt = DateTimeParse.DTT.NumEnd;
								break;
							}
							if (separatorToken4 != TokenType.SEP_Space)
							{
								goto IL_695;
							}
						}
						else
						{
							if (separatorToken4 != TokenType.SEP_Date)
							{
								if (separatorToken4 != TokenType.SEP_DateOrOffset)
								{
									goto IL_695;
								}
								if (DateTimeParse.dateParsingStates[(int)dps][4] == DateTimeParse.DS.ERROR && DateTimeParse.dateParsingStates[(int)dps][3] > DateTimeParse.DS.ERROR)
								{
									str.Index = index;
									str.m_current = current;
									dtok.dtt = DateTimeParse.DTT.NumSpace;
									break;
								}
								dtok.dtt = DateTimeParse.DTT.NumDatesep;
								break;
							}
						}
						dtok.dtt = DateTimeParse.DTT.NumDatesep;
						break;
						IL_695:
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					if (raw.year != -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					raw.year = num;
					TokenType separatorToken5 = str.GetSeparatorToken(dtfi, out index, out current);
					if (separatorToken5 != TokenType.SEP_End)
					{
						if (separatorToken5 != TokenType.SEP_Space)
						{
							if (separatorToken5 == TokenType.SEP_DateOrOffset)
							{
								if (DateTimeParse.dateParsingStates[(int)dps][12] > DateTimeParse.DS.ERROR)
								{
									str.Index = index;
									str.m_current = current;
									dtok.dtt = DateTimeParse.DTT.YearSpace;
									break;
								}
							}
							result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
							return false;
						}
						dtok.dtt = DateTimeParse.DTT.YearSpace;
					}
					else
					{
						dtok.dtt = DateTimeParse.DTT.YearEnd;
					}
					break;
				}
				case TokenType.JapaneseEraToken:
				{
					result.calendar = JapaneseCalendar.GetDefaultInstance();
					dtfi = DateTimeFormatInfo.GetJapaneseCalendarDTFI();
					if (result.era == -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					result.era = num;
					dtok.dtt = DateTimeParse.DTT.Era;
					break;
				}
				case TokenType.TEraToken:
				{
					result.calendar = TaiwanCalendar.GetDefaultInstance();
					dtfi = DateTimeFormatInfo.GetTaiwanCalendarDTFI();
					if (result.era == -1)
					{
						result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
						return false;
					}
					result.era = num;
					dtok.dtt = DateTimeParse.DTT.Era;
					break;
				}
			}
			return true;
		}