internal static DateTime ParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style) {
DateTimeResult result = new DateTimeResult(); // The buffer to store the parsing result.
result.Init();
if (TryParseExact(s, format, dtfi, style, ref result)) {
return result.parsedDate;
}
else {
throw GetDateTimeParseException(ref result);
}
}
internal static bool TryParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result) {
result = DateTime.MinValue;
DateTimeResult resultData = new DateTimeResult(); // The buffer to store the parsing result.
resultData.Init();
if (TryParseExact(s, format, dtfi, style, ref resultData)) {
result = resultData.parsedDate;
return true;
}
return false;
}
internal static DateTime ParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out TimeSpan offset) {
DateTimeResult result = new DateTimeResult(); // The buffer to store the parsing result.
offset = TimeSpan.Zero;
result.Init();
result.flags |= ParseFlags.CaptureOffset;
if (TryParseExact(s, format, dtfi, style, ref result)) {
offset = result.timeZoneOffset;
return result.parsedDate;
}
else {
throw GetDateTimeParseException(ref result);
}
}
internal static bool TryParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result, out TimeSpan offset) {
result = DateTime.MinValue;
offset = TimeSpan.Zero;
DateTimeResult resultData = new DateTimeResult(); // The buffer to store the parsing result.
resultData.Init();
resultData.flags |= ParseFlags.CaptureOffset;
if (TryParseExact(s, format, dtfi, style, ref resultData)) {
result = resultData.parsedDate;
offset = resultData.timeZoneOffset;
return true;
}
return false;
}
internal static bool TryParseExact(String s, String format, IFormatProvider provider, DateTimeStyles style, out DateTime result)
{
DateTimeFormatInfo dtfi = provider == null ? DateTimeFormatInfo.CurrentInfo : DateTimeFormatInfo.GetInstance(provider);
result = DateTime.MinValue;
DateTimeResult resultData = new DateTimeResult(); // The buffer to store the parsing result.
resultData.Init();
if (TryParseExact(s, format, dtfi, style, ref resultData))
{
result = resultData.parsedDate;
return true;
}
return false;
}
internal static DateTime ParseExact(String s, String format, IFormatProvider provider, DateTimeStyles style)
{
DateTimeFormatInfo dtfi = provider == null ? DateTimeFormatInfo.CurrentInfo : DateTimeFormatInfo.GetInstance(provider);
DateTimeResult result = new DateTimeResult(); // The buffer to store the parsing result.
result.Init();
if (TryParseExact(s, format, dtfi, style, ref result))
{
return result.parsedDate;
}
else
{
throw GetDateTimeParseException(ref result);
}
}
internal static bool TryParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, ref DateTimeResult result) {
if (s == null) {
result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "s");
return false;
}
if (format == null) {
result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "format");
return false;
}
if (s.Length == 0) {
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (format.Length == 0) {
result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
return false;
}
BCLDebug.Assert(dtfi != null, "dtfi == null");
return DoStrictParse(s, format, style, dtfi, ref result);
}
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;
}
internal static bool TryParseExactMultiple(string s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, ref DateTimeResult result)
{
if (s == null)
{
result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "s");
return false;
}
if (formats == null)
{
result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "formats");
return false;
}
if (s.Length == 0)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (formats.Length == 0)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
return false;
}
for (int i = 0; i < formats.Length; i++)
{
if (formats[i] == null || formats[i].Length == 0)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
return false;
}
DateTimeResult dateTimeResult = default(DateTimeResult);
dateTimeResult.Init();
dateTimeResult.flags = result.flags;
if (DateTimeParse.TryParseExact(s, formats[i], dtfi, style, ref dateTimeResult))
{
result.parsedDate = dateTimeResult.parsedDate;
result.timeZoneOffset = dateTimeResult.timeZoneOffset;
return true;
}
}
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
private static bool DoStrictParse(string s, string formatParam, DateTimeStyles styles, DateTimeFormatInfo dtfi, ref DateTimeResult result)
{
ParsingInfo parsingInfo = default(ParsingInfo);
parsingInfo.Init();
parsingInfo.calendar = dtfi.Calendar;
parsingInfo.fAllowInnerWhite = ((styles & DateTimeStyles.AllowInnerWhite) != DateTimeStyles.None);
parsingInfo.fAllowTrailingWhite = ((styles & DateTimeStyles.AllowTrailingWhite) != DateTimeStyles.None);
if (formatParam.Length == 1)
{
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0 && formatParam[0] == 'U')
{
result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
return false;
}
formatParam = DateTimeParse.ExpandPredefinedFormat(formatParam, ref dtfi, ref parsingInfo, ref result);
}
result.calendar = parsingInfo.calendar;
if (parsingInfo.calendar.ID == 8)
{
parsingInfo.parseNumberDelegate = DateTimeParse.m_hebrewNumberParser;
parsingInfo.fCustomNumberParser = true;
}
result.Hour = (result.Minute = (result.Second = -1));
__DTString _DTString = new __DTString(formatParam, dtfi, false);
__DTString _DTString2 = new __DTString(s, dtfi, false);
if (parsingInfo.fAllowTrailingWhite)
{
_DTString.TrimTail();
_DTString.RemoveTrailingInQuoteSpaces();
_DTString2.TrimTail();
}
if ((styles & DateTimeStyles.AllowLeadingWhite) != DateTimeStyles.None)
{
_DTString.SkipWhiteSpaces();
_DTString.RemoveLeadingInQuoteSpaces();
_DTString2.SkipWhiteSpaces();
}
while (_DTString.GetNext())
{
if (parsingInfo.fAllowInnerWhite)
{
_DTString2.SkipWhiteSpaces();
}
if (!DateTimeParse.ParseByFormat(ref _DTString2, ref _DTString, ref parsingInfo, dtfi, ref result))
{
return false;
}
}
if (_DTString2.Index < _DTString2.Value.Length - 1)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (parsingInfo.fUseTwoDigitYear && (dtfi.FormatFlags & DateTimeFormatFlags.UseHebrewRule) == DateTimeFormatFlags.None)
{
if (result.Year >= 100)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
result.Year = parsingInfo.calendar.ToFourDigitYear(result.Year);
}
if (parsingInfo.fUseHour12)
{
if (parsingInfo.timeMark == DateTimeParse.TM.NotSet)
{
parsingInfo.timeMark = DateTimeParse.TM.AM;
}
if (result.Hour > 12)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (parsingInfo.timeMark == DateTimeParse.TM.AM)
{
if (result.Hour == 12)
{
result.Hour = 0;
}
}
else
{
result.Hour = ((result.Hour == 12) ? 12 : (result.Hour + 12));
}
}
else
{
if ((parsingInfo.timeMark == DateTimeParse.TM.AM && result.Hour >= 12) || (parsingInfo.timeMark == DateTimeParse.TM.PM && result.Hour < 12))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
bool flag = result.Year == -1 && result.Month == -1 && result.Day == -1;
if (!DateTimeParse.CheckDefaultDateTime(ref result, ref parsingInfo.calendar, styles))
{
return false;
}
if (!flag && dtfi.HasYearMonthAdjustment && !dtfi.YearMonthAdjustment(ref result.Year, ref result.Month, (result.flags & ParseFlags.ParsedMonthName) != (ParseFlags)0))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (!parsingInfo.calendar.TryToDateTime(result.Year, result.Month, result.Day, result.Hour, result.Minute, result.Second, 0, result.era, out result.parsedDate))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (result.fraction > 0.0)
{
result.parsedDate = result.parsedDate.AddTicks((long)Math.Round(result.fraction * 10000000.0));
}
if (parsingInfo.dayOfWeek != -1 && parsingInfo.dayOfWeek != (int)parsingInfo.calendar.GetDayOfWeek(result.parsedDate))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDayOfWeek", null);
return false;
}
return DateTimeParse.DetermineTimeZoneAdjustments(ref result, styles, flag);
}
private static string ExpandPredefinedFormat(string format, ref DateTimeFormatInfo dtfi, ref ParsingInfo parseInfo, ref DateTimeResult result)
{
char c = format[0];
if (c <= 'R')
{
if (c != 'O')
{
if (c != 'R')
{
goto IL_160;
}
goto IL_65;
}
}
else
{
if (c != 'U')
{
switch (c)
{
case 'o':
{
break;
}
case 'p':
case 'q':
case 't':
{
goto IL_160;
}
case 'r':
{
goto IL_65;
}
case 's':
{
dtfi = DateTimeFormatInfo.InvariantInfo;
parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
goto IL_160;
}
case 'u':
{
parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
dtfi = DateTimeFormatInfo.InvariantInfo;
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0)
{
result.flags |= ParseFlags.UtcSortPattern;
goto IL_160;
}
goto IL_160;
}
default:
{
goto IL_160;
}
}
}
else
{
parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = new TimeSpan(0L);
result.flags |= ParseFlags.TimeZoneUtc;
if (dtfi.Calendar.GetType() != typeof(GregorianCalendar))
{
dtfi = (DateTimeFormatInfo)dtfi.Clone();
dtfi.Calendar = GregorianCalendar.GetDefaultInstance();
goto IL_160;
}
goto IL_160;
}
}
parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
dtfi = DateTimeFormatInfo.InvariantInfo;
goto IL_160;
IL_65:
parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
dtfi = DateTimeFormatInfo.InvariantInfo;
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0)
{
result.flags |= ParseFlags.Rfc1123Pattern;
}
IL_160:
return DateTimeFormat.GetRealFormat(format, dtfi);
}
private static DateTime GetDateTimeNow(ref DateTimeResult result, ref DateTimeStyles styles)
{
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0)
{
if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0)
{
return new DateTime(DateTime.UtcNow.Ticks + result.timeZoneOffset.Ticks, DateTimeKind.Unspecified);
}
if ((styles & 64) != 0)
{
return DateTime.UtcNow;
}
}
return DateTime.Now;
}
private static bool ParseISO8601(ref DateTimeRawInfo raw, ref __DTString str, DateTimeStyles styles, ref DateTimeResult result)
{
if (raw.year >= 0 && raw.GetNumber(0) >= 0)
{
raw.GetNumber(1);
}
str.Index--;
int second = 0;
double num = 0.0;
str.SkipWhiteSpaces();
int hour;
if (!DateTimeParse.ParseDigits(ref str, 2, out hour))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
str.SkipWhiteSpaces();
if (!str.Match(':'))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
str.SkipWhiteSpaces();
int minute;
if (!DateTimeParse.ParseDigits(ref str, 2, out minute))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
str.SkipWhiteSpaces();
if (str.Match(':'))
{
str.SkipWhiteSpaces();
if (!DateTimeParse.ParseDigits(ref str, 2, out second))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (str.Match('.'))
{
if (!DateTimeParse.ParseFraction(ref str, out num))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
str.Index--;
}
str.SkipWhiteSpaces();
}
if (str.GetNext())
{
char @char = str.GetChar();
if (@char == '+' || @char == '-')
{
result.flags |= ParseFlags.TimeZoneUsed;
if (!DateTimeParse.ParseTimeZone(ref str, ref result.timeZoneOffset))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (@char == 'Z' || @char == 'z')
{
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = TimeSpan.Zero;
result.flags |= ParseFlags.TimeZoneUtc;
}
else
{
str.Index--;
}
}
str.SkipWhiteSpaces();
if (str.Match('#'))
{
if (!DateTimeParse.VerifyValidPunctuation(ref str))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
str.SkipWhiteSpaces();
}
if (str.Match('\0') && !DateTimeParse.VerifyValidPunctuation(ref str))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (str.GetNext())
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
Calendar defaultInstance = GregorianCalendar.GetDefaultInstance();
DateTime parsedDate;
if (!defaultInstance.TryToDateTime(raw.year, raw.GetNumber(0), raw.GetNumber(1), hour, minute, second, 0, result.era, out parsedDate))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
parsedDate = parsedDate.AddTicks((long)Math.Round(num * 10000000.0));
result.parsedDate = parsedDate;
return DateTimeParse.DetermineTimeZoneAdjustments(ref result, styles, false);
}
private static bool GetDateOfNDS(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if (result.Month == -1)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (result.Year != -1)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
result.Year = DateTimeParse.AdjustYear(ref result, raw.GetNumber(0));
result.Day = 1;
return true;
}
private static bool GetDateOfDSN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if (raw.numCount != 1 || result.Day != -1)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
result.Day = raw.GetNumber(0);
return true;
}
private static bool AdjustTimeZoneToUniversal(ref DateTimeResult result)
{
long num = result.parsedDate.Ticks;
num -= result.timeZoneOffset.Ticks;
if (num < 0L)
{
num += 864000000000L;
}
if (num < 0L || num > 3155378975999999999L)
{
result.SetFailure(ParseFailureKind.Format, "Format_DateOutOfRange", null);
return false;
}
result.parsedDate = new DateTime(num, DateTimeKind.Utc);
return true;
}
private static bool AdjustTimeZoneToLocal(ref DateTimeResult result, bool bTimeOnly)
{
long num = result.parsedDate.Ticks;
TimeZoneInfo local = TimeZoneInfo.Local;
bool isAmbiguousDst = false;
if (num < 864000000000L)
{
num -= result.timeZoneOffset.Ticks;
num += local.GetUtcOffset(bTimeOnly ? DateTime.Now : result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
if (num < 0L)
{
num += 864000000000L;
}
}
else
{
num -= result.timeZoneOffset.Ticks;
if (num < 0L || num > 3155378975999999999L)
{
num += local.GetUtcOffset(result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
}
else
{
DateTime time = new DateTime(num, DateTimeKind.Utc);
bool flag = false;
num += TimeZoneInfo.GetUtcOffsetFromUtc(time, TimeZoneInfo.Local, out flag, out isAmbiguousDst).Ticks;
}
}
if (num < 0L || num > 3155378975999999999L)
{
result.parsedDate = DateTime.MinValue;
result.SetFailure(ParseFailureKind.Format, "Format_DateOutOfRange", null);
return false;
}
result.parsedDate = new DateTime(num, DateTimeKind.Local, isAmbiguousDst);
return true;
}
private static bool GetDateOfNNDS(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveYear) != (ParseFlags)0)
{
if ((result.flags & ParseFlags.HaveMonth) == (ParseFlags)0 && (result.flags & ParseFlags.HaveDay) == (ParseFlags)0 && DateTimeParse.SetDateYMD(ref result, result.Year = DateTimeParse.AdjustYear(ref result, raw.year), raw.GetNumber(0), raw.GetNumber(1)))
{
return true;
}
}
else
{
if ((result.flags & ParseFlags.HaveMonth) != (ParseFlags)0 && (result.flags & ParseFlags.HaveYear) == (ParseFlags)0 && (result.flags & ParseFlags.HaveDay) == (ParseFlags)0)
{
int num;
if (!DateTimeParse.GetYearMonthDayOrder(dtfi.ShortDatePattern, dtfi, out num))
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
return false;
}
if (num == 0)
{
if (DateTimeParse.SetDateYMD(ref result, DateTimeParse.AdjustYear(ref result, raw.GetNumber(0)), result.Month, raw.GetNumber(1)))
{
return true;
}
}
else
{
if (DateTimeParse.SetDateYMD(ref result, DateTimeParse.AdjustYear(ref result, raw.GetNumber(1)), result.Month, raw.GetNumber(0)))
{
return true;
}
}
}
}
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
private static bool CheckNewValue(ref int currentValue, int newValue, char patternChar, ref DateTimeResult result)
{
if (currentValue == -1)
{
currentValue = newValue;
return true;
}
if (newValue != currentValue)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", patternChar);
return false;
}
return true;
}
private static bool ProcessDateTimeSuffix(ref DateTimeResult result, ref DateTimeRawInfo raw, ref DateTimeToken dtok)
{
TokenType suffix = dtok.suffix;
if (suffix <= TokenType.SEP_DaySuff)
{
if (suffix != TokenType.SEP_YearSuff)
{
if (suffix != TokenType.SEP_MonthSuff)
{
if (suffix == TokenType.SEP_DaySuff)
{
if ((result.flags & ParseFlags.HaveDay) != (ParseFlags)0)
{
return false;
}
result.flags |= ParseFlags.HaveDay;
result.Day = dtok.num;
}
}
else
{
if ((result.flags & ParseFlags.HaveMonth) != (ParseFlags)0)
{
return false;
}
result.flags |= ParseFlags.HaveMonth;
result.Month = (raw.month = dtok.num);
}
}
else
{
if ((result.flags & ParseFlags.HaveYear) != (ParseFlags)0)
{
return false;
}
result.flags |= ParseFlags.HaveYear;
result.Year = (raw.year = dtok.num);
}
}
else
{
if (suffix != TokenType.SEP_HourSuff)
{
if (suffix != TokenType.SEP_MinuteSuff)
{
if (suffix == TokenType.SEP_SecondSuff)
{
if ((result.flags & ParseFlags.HaveSecond) != (ParseFlags)0)
{
return false;
}
result.flags |= ParseFlags.HaveSecond;
result.Second = dtok.num;
}
}
else
{
if ((result.flags & ParseFlags.HaveMinute) != (ParseFlags)0)
{
return false;
}
result.flags |= ParseFlags.HaveMinute;
result.Minute = dtok.num;
}
}
else
{
if ((result.flags & ParseFlags.HaveHour) != (ParseFlags)0)
{
return false;
}
result.flags |= ParseFlags.HaveHour;
result.Hour = dtok.num;
}
}
return true;
}
private static bool CheckDefaultDateTime(ref DateTimeResult result, ref Calendar cal, DateTimeStyles styles)
{
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0 && (result.Month != -1 || result.Day != -1) && (result.Year == -1 || (result.flags & ParseFlags.YearDefault) != (ParseFlags)0) && (result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0)
{
result.SetFailure(ParseFailureKind.Format, "Format_MissingIncompleteDate", null);
return false;
}
if (result.Year == -1 || result.Month == -1 || result.Day == -1)
{
DateTime dateTimeNow = DateTimeParse.GetDateTimeNow(ref result, ref styles);
if (result.Month == -1 && result.Day == -1)
{
if (result.Year == -1)
{
if ((styles & DateTimeStyles.NoCurrentDateDefault) != DateTimeStyles.None)
{
cal = GregorianCalendar.GetDefaultInstance();
result.Year = (result.Month = (result.Day = 1));
}
else
{
result.Year = cal.GetYear(dateTimeNow);
result.Month = cal.GetMonth(dateTimeNow);
result.Day = cal.GetDayOfMonth(dateTimeNow);
}
}
else
{
result.Month = 1;
result.Day = 1;
}
}
else
{
if (result.Year == -1)
{
result.Year = cal.GetYear(dateTimeNow);
}
if (result.Month == -1)
{
result.Month = 1;
}
if (result.Day == -1)
{
result.Day = 1;
}
}
}
if (result.Hour == -1)
{
result.Hour = 0;
}
if (result.Minute == -1)
{
result.Minute = 0;
}
if (result.Second == -1)
{
result.Second = 0;
}
if (result.era == -1)
{
result.era = 0;
}
return true;
}
internal static bool ProcessHebrewTerminalState(DateTimeParse.DS dps, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
switch (dps)
{
case DateTimeParse.DS.DX_MN:
case DateTimeParse.DS.DX_NM:
{
DateTimeParse.GetDefaultYear(ref result, ref styles);
if (!dtfi.YearMonthAdjustment(ref result.Year, ref raw.month, true))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (!DateTimeParse.GetHebrewDayOfNM(ref result, ref raw, dtfi))
{
return false;
}
goto IL_160;
}
case DateTimeParse.DS.DX_MNN:
{
raw.year = raw.GetNumber(1);
if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, true))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (!DateTimeParse.GetDayOfMNN(ref result, ref raw, dtfi))
{
return false;
}
goto IL_160;
}
case DateTimeParse.DS.DX_YMN:
{
if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, true))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (!DateTimeParse.GetDayOfYMN(ref result, ref raw, dtfi))
{
return false;
}
goto IL_160;
}
case DateTimeParse.DS.DX_YM:
{
if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, true))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (!DateTimeParse.GetDayOfYM(ref result, ref raw, dtfi))
{
return false;
}
goto IL_160;
}
case DateTimeParse.DS.TX_N:
{
if (!DateTimeParse.GetTimeOfN(dtfi, ref result, ref raw))
{
return false;
}
goto IL_160;
}
case DateTimeParse.DS.TX_NN:
{
if (!DateTimeParse.GetTimeOfNN(dtfi, ref result, ref raw))
{
return false;
}
goto IL_160;
}
case DateTimeParse.DS.TX_NNN:
{
if (!DateTimeParse.GetTimeOfNNN(dtfi, ref result, ref raw))
{
return false;
}
goto IL_160;
}
}
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
IL_160:
if (dps > DateTimeParse.DS.ERROR)
{
raw.numCount = 0;
}
return true;
}
private static bool ParseByFormat(ref __DTString str, ref __DTString format, ref ParsingInfo parseInfo, DateTimeFormatInfo dtfi, ref DateTimeResult result)
{
int num = 0;
int newValue = 0;
int newValue2 = 0;
int newValue3 = 0;
int newValue4 = 0;
int newValue5 = 0;
int newValue6 = 0;
int newValue7 = 0;
double num2 = 0.0;
DateTimeParse.TM tM = DateTimeParse.TM.AM;
char @char = format.GetChar();
char c = @char;
if (c <= 'H')
{
if (c <= '\'')
{
if (c != '"')
{
switch (c)
{
case '%':
{
if (format.Index >= format.Value.Length - 1 || format.Value[format.Index + 1] == '%')
{
result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
return false;
}
return true;
}
case '&':
{
goto IL_991;
}
case '\'':
{
break;
}
default:
{
goto IL_991;
}
}
}
StringBuilder stringBuilder = new StringBuilder();
if (!DateTimeParse.TryParseQuoteString(format.Value, format.Index, stringBuilder, out num))
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadQuote", @char);
return false;
}
format.Index += num - 1;
string text = stringBuilder.ToString();
for (int i = 0; i < text.Length; i++)
{
if (text[i] == ' ' && parseInfo.fAllowInnerWhite)
{
str.SkipWhiteSpaces();
}
else
{
if (!str.Match(text[i]))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
}
if ((result.flags & ParseFlags.CaptureOffset) == (ParseFlags)0)
{
return true;
}
if ((result.flags & ParseFlags.Rfc1123Pattern) != (ParseFlags)0 && text == "GMT")
{
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = TimeSpan.Zero;
return true;
}
if ((result.flags & ParseFlags.UtcSortPattern) != (ParseFlags)0 && text == "Z")
{
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = TimeSpan.Zero;
return true;
}
return true;
}
else
{
switch (c)
{
case '.':
{
if (str.Match(@char))
{
return true;
}
if (format.GetNext() && format.Match('F'))
{
format.GetRepeatCount();
return true;
}
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
case '/':
{
if (!str.Match(dtfi.DateSeparator))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
return true;
}
default:
{
if (c != ':')
{
switch (c)
{
case 'F':
{
break;
}
case 'G':
{
goto IL_991;
}
case 'H':
{
num = format.GetRepeatCount();
if (!DateTimeParse.ParseDigits(ref str, (num < 2) ? 1 : 2, out newValue5))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.CheckNewValue(ref result.Hour, newValue5, @char, ref result))
{
return false;
}
return true;
}
default:
{
goto IL_991;
}
}
}
else
{
if (!str.Match(dtfi.TimeSeparator))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
return true;
}
break;
}
}
}
}
else
{
if (c <= 'h')
{
switch (c)
{
case 'K':
{
if (str.Match('Z'))
{
if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0 && result.timeZoneOffset != TimeSpan.Zero)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'K');
return false;
}
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = new TimeSpan(0L);
result.flags |= ParseFlags.TimeZoneUtc;
return true;
}
else
{
if (!str.Match('+') && !str.Match('-'))
{
return true;
}
str.Index--;
TimeSpan timeSpan = new TimeSpan(0L);
if (!DateTimeParse.ParseTimeZoneOffset(ref str, 3, ref timeSpan))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0 && timeSpan != result.timeZoneOffset)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'K');
return false;
}
result.timeZoneOffset = timeSpan;
result.flags |= ParseFlags.TimeZoneUsed;
return true;
}
break;
}
case 'L':
{
goto IL_991;
}
case 'M':
{
num = format.GetRepeatCount();
if (num <= 2)
{
if (!DateTimeParse.ParseDigits(ref str, num, out newValue2) && (!parseInfo.fCustomNumberParser || !parseInfo.parseNumberDelegate(ref str, num, out newValue2)))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (num == 3)
{
if (!DateTimeParse.MatchAbbreviatedMonthName(ref str, dtfi, ref newValue2))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (!DateTimeParse.MatchMonthName(ref str, dtfi, ref newValue2))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
result.flags |= ParseFlags.ParsedMonthName;
}
if (!DateTimeParse.CheckNewValue(ref result.Month, newValue2, @char, ref result))
{
return false;
}
return true;
}
default:
{
switch (c)
{
case 'Z':
{
if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0 && result.timeZoneOffset != TimeSpan.Zero)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'Z');
return false;
}
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = new TimeSpan(0L);
result.flags |= ParseFlags.TimeZoneUtc;
str.Index++;
if (!DateTimeParse.GetTimeZoneName(ref str))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
str.Index--;
return true;
}
case '[':
{
goto IL_991;
}
case '\\':
{
if (!format.GetNext())
{
result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
return false;
}
if (!str.Match(format.GetChar()))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
return true;
}
default:
{
switch (c)
{
case 'd':
{
num = format.GetRepeatCount();
if (num <= 2)
{
if (!DateTimeParse.ParseDigits(ref str, num, out newValue3) && (!parseInfo.fCustomNumberParser || !parseInfo.parseNumberDelegate(ref str, num, out newValue3)))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.CheckNewValue(ref result.Day, newValue3, @char, ref result))
{
return false;
}
return true;
}
else
{
if (num == 3)
{
if (!DateTimeParse.MatchAbbreviatedDayName(ref str, dtfi, ref newValue4))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (!DateTimeParse.MatchDayName(ref str, dtfi, ref newValue4))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
if (!DateTimeParse.CheckNewValue(ref parseInfo.dayOfWeek, newValue4, @char, ref result))
{
return false;
}
return true;
}
break;
}
case 'e':
{
goto IL_991;
}
case 'f':
{
break;
}
case 'g':
{
num = format.GetRepeatCount();
if (!DateTimeParse.MatchEraName(ref str, dtfi, ref result.era))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
return true;
}
case 'h':
{
parseInfo.fUseHour12 = true;
num = format.GetRepeatCount();
if (!DateTimeParse.ParseDigits(ref str, (num < 2) ? 1 : 2, out newValue5))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.CheckNewValue(ref result.Hour, newValue5, @char, ref result))
{
return false;
}
return true;
}
default:
{
goto IL_991;
}
}
break;
}
}
break;
}
}
}
else
{
if (c != 'm')
{
switch (c)
{
case 's':
{
num = format.GetRepeatCount();
if (!DateTimeParse.ParseDigits(ref str, (num < 2) ? 1 : 2, out newValue7))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.CheckNewValue(ref result.Second, newValue7, @char, ref result))
{
return false;
}
return true;
}
case 't':
{
num = format.GetRepeatCount();
if (num == 1)
{
if (!DateTimeParse.MatchAbbreviatedTimeMark(ref str, dtfi, ref tM))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (!DateTimeParse.MatchTimeMark(ref str, dtfi, ref tM))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
if (parseInfo.timeMark == DateTimeParse.TM.NotSet)
{
parseInfo.timeMark = tM;
return true;
}
if (parseInfo.timeMark != tM)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", @char);
return false;
}
return true;
}
default:
{
switch (c)
{
case 'y':
{
num = format.GetRepeatCount();
bool flag;
if (dtfi.HasForceTwoDigitYears)
{
flag = DateTimeParse.ParseDigits(ref str, 1, 4, out newValue);
}
else
{
if (num <= 2)
{
parseInfo.fUseTwoDigitYear = true;
}
flag = DateTimeParse.ParseDigits(ref str, num, out newValue);
}
if (!flag && parseInfo.fCustomNumberParser)
{
flag = parseInfo.parseNumberDelegate(ref str, num, out newValue);
}
if (!flag)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.CheckNewValue(ref result.Year, newValue, @char, ref result))
{
return false;
}
return true;
}
case 'z':
{
num = format.GetRepeatCount();
TimeSpan timeSpan2 = new TimeSpan(0L);
if (!DateTimeParse.ParseTimeZoneOffset(ref str, num, ref timeSpan2))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0 && timeSpan2 != result.timeZoneOffset)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'z');
return false;
}
result.timeZoneOffset = timeSpan2;
result.flags |= ParseFlags.TimeZoneUsed;
return true;
}
default:
{
goto IL_991;
}
}
break;
}
}
}
else
{
num = format.GetRepeatCount();
if (!DateTimeParse.ParseDigits(ref str, (num < 2) ? 1 : 2, out newValue6))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.CheckNewValue(ref result.Minute, newValue6, @char, ref result))
{
return false;
}
return true;
}
}
}
num = format.GetRepeatCount();
if (num > 7)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (!DateTimeParse.ParseFractionExact(ref str, num, ref num2) && @char == 'f')
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (result.fraction < 0.0)
{
result.fraction = num2;
return true;
}
if (num2 != result.fraction)
{
result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", @char);
return false;
}
return true;
IL_991:
if (@char == ' ')
{
if (!parseInfo.fAllowInnerWhite && !str.Match(@char))
{
if (parseInfo.fAllowTrailingWhite && format.GetNext() && DateTimeParse.ParseByFormat(ref str, ref format, ref parseInfo, dtfi, ref result))
{
return true;
}
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (format.MatchSpecifiedWord("GMT"))
{
format.Index += "GMT".Length - 1;
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = TimeSpan.Zero;
if (!str.Match("GMT"))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
else
{
if (!str.Match(@char))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
}
return true;
}
internal static bool ProcessTerminaltState(DateTimeParse.DS dps, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
bool flag = true;
switch (dps)
{
case DateTimeParse.DS.DX_NN:
{
flag = DateTimeParse.GetDayOfNN(ref result, ref styles, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_NNN:
{
flag = DateTimeParse.GetDayOfNNN(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_MN:
{
flag = DateTimeParse.GetDayOfMN(ref result, ref styles, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_NM:
{
flag = DateTimeParse.GetDayOfNM(ref result, ref styles, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_MNN:
{
flag = DateTimeParse.GetDayOfMNN(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_DS:
{
flag = true;
break;
}
case DateTimeParse.DS.DX_DSN:
{
flag = DateTimeParse.GetDateOfDSN(ref result, ref raw);
break;
}
case DateTimeParse.DS.DX_NDS:
{
flag = DateTimeParse.GetDateOfNDS(ref result, ref raw);
break;
}
case DateTimeParse.DS.DX_NNDS:
{
flag = DateTimeParse.GetDateOfNNDS(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_YNN:
{
flag = DateTimeParse.GetDayOfYNN(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_YMN:
{
flag = DateTimeParse.GetDayOfYMN(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_YN:
{
flag = DateTimeParse.GetDayOfYN(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.DX_YM:
{
flag = DateTimeParse.GetDayOfYM(ref result, ref raw, dtfi);
break;
}
case DateTimeParse.DS.TX_N:
{
flag = DateTimeParse.GetTimeOfN(dtfi, ref result, ref raw);
break;
}
case DateTimeParse.DS.TX_NN:
{
flag = DateTimeParse.GetTimeOfNN(dtfi, ref result, ref raw);
break;
}
case DateTimeParse.DS.TX_NNN:
{
flag = DateTimeParse.GetTimeOfNNN(dtfi, ref result, ref raw);
break;
}
case DateTimeParse.DS.TX_TS:
{
flag = true;
break;
}
case DateTimeParse.DS.DX_NNY:
{
flag = DateTimeParse.GetDayOfNNY(ref result, ref raw, dtfi);
break;
}
}
if (!flag)
{
return false;
}
if (dps > DateTimeParse.DS.ERROR)
{
raw.numCount = 0;
}
return true;
}
private static Exception GetDateTimeParseException(ref DateTimeResult result)
{
switch (result.failure)
{
case ParseFailureKind.ArgumentNull:
{
return new ArgumentNullException(result.failureArgumentName, Environment.GetResourceString(result.failureMessageID));
}
case ParseFailureKind.Format:
{
return new FormatException(Environment.GetResourceString(result.failureMessageID));
}
case ParseFailureKind.FormatWithParameter:
{
return new FormatException(Environment.GetResourceString(result.failureMessageID, new object[]
{
result.failureMessageFormatArgument
}));
}
case ParseFailureKind.FormatBadDateTimeCalendar:
{
return new FormatException(Environment.GetResourceString(result.failureMessageID, new object[]
{
result.calendar
}));
}
default:
{
return null;
}
}
}
internal unsafe static bool TryParse(string s, DateTimeFormatInfo dtfi, DateTimeStyles styles, ref DateTimeResult result)
{
if (s == null)
{
result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "s");
return false;
}
if (s.Length == 0)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
DateTimeParse.DS dS = DateTimeParse.DS.BEGIN;
bool flag = false;
DateTimeToken dateTimeToken = default(DateTimeToken);
dateTimeToken.suffix = TokenType.SEP_Unk;
DateTimeRawInfo dateTimeRawInfo = default(DateTimeRawInfo);
int* numberBuffer = stackalloc int[(UIntPtr)3];
dateTimeRawInfo.Init(numberBuffer);
result.calendar = dtfi.Calendar;
result.era = 0;
__DTString _DTString = new __DTString(s, dtfi);
_DTString.GetNext();
while (DateTimeParse.Lex(dS, ref _DTString, ref dateTimeToken, ref dateTimeRawInfo, ref result, ref dtfi))
{
if (dateTimeToken.dtt != DateTimeParse.DTT.Unk)
{
if (dateTimeToken.suffix != TokenType.SEP_Unk)
{
if (!DateTimeParse.ProcessDateTimeSuffix(ref result, ref dateTimeRawInfo, ref dateTimeToken))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
dateTimeToken.suffix = TokenType.SEP_Unk;
}
if (dateTimeToken.dtt == DateTimeParse.DTT.NumLocalTimeMark)
{
if (dS == DateTimeParse.DS.D_YNd || dS == DateTimeParse.DS.D_YN)
{
return DateTimeParse.ParseISO8601(ref dateTimeRawInfo, ref _DTString, styles, ref result);
}
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
else
{
dS = DateTimeParse.dateParsingStates[(int)dS][(int)dateTimeToken.dtt];
if (dS == DateTimeParse.DS.ERROR)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
if (dS > DateTimeParse.DS.ERROR)
{
if ((dtfi.FormatFlags & DateTimeFormatFlags.UseHebrewRule) != DateTimeFormatFlags.None)
{
if (!DateTimeParse.ProcessHebrewTerminalState(dS, ref result, ref styles, ref dateTimeRawInfo, dtfi))
{
return false;
}
}
else
{
if (!DateTimeParse.ProcessTerminaltState(dS, ref result, ref styles, ref dateTimeRawInfo, dtfi))
{
return false;
}
}
flag = true;
dS = DateTimeParse.DS.BEGIN;
}
}
}
if (dateTimeToken.dtt == DateTimeParse.DTT.End || dateTimeToken.dtt == DateTimeParse.DTT.NumEnd || dateTimeToken.dtt == DateTimeParse.DTT.MonthEnd)
{
if (!flag)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
DateTimeParse.AdjustTimeMark(dtfi, ref dateTimeRawInfo);
if (!DateTimeParse.AdjustHour(ref result.Hour, dateTimeRawInfo.timeMark))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
bool bTimeOnly = result.Year == -1 && result.Month == -1 && result.Day == -1;
if (!DateTimeParse.CheckDefaultDateTime(ref result, ref result.calendar, styles))
{
return false;
}
DateTime dateTime;
if (!result.calendar.TryToDateTime(result.Year, result.Month, result.Day, result.Hour, result.Minute, result.Second, 0, result.era, out dateTime))
{
result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
return false;
}
if (dateTimeRawInfo.fraction > 0.0)
{
dateTime = dateTime.AddTicks((long)Math.Round(dateTimeRawInfo.fraction * 10000000.0));
}
if (dateTimeRawInfo.dayOfWeek != -1 && dateTimeRawInfo.dayOfWeek != (int)result.calendar.GetDayOfWeek(dateTime))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDayOfWeek", null);
return false;
}
result.parsedDate = dateTime;
return DateTimeParse.DetermineTimeZoneAdjustments(ref result, styles, bTimeOnly);
}
}
return false;
}
private static bool HandleTimeZone(ref __DTString str, ref DateTimeResult result)
{
if (str.Index < str.len - 1)
{
char c = str.Value[str.Index];
int num = 0;
while (char.IsWhiteSpace(c) && str.Index + num < str.len - 1)
{
num++;
c = str.Value[str.Index + num];
}
if (c == '+' || c == '-')
{
str.Index += num;
if ((result.flags & ParseFlags.TimeZoneUsed) != (ParseFlags)0)
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
result.flags |= ParseFlags.TimeZoneUsed;
if (!DateTimeParse.ParseTimeZone(ref str, ref result.timeZoneOffset))
{
result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
return false;
}
}
}
return true;
}
private static bool DetermineTimeZoneAdjustments(ref DateTimeResult result, DateTimeStyles styles, bool bTimeOnly)
{
if ((result.flags & ParseFlags.CaptureOffset) != (ParseFlags)0)
{
return DateTimeParse.DateTimeOffsetTimeZonePostProcessing(ref result, styles);
}
if ((result.flags & ParseFlags.TimeZoneUsed) == (ParseFlags)0)
{
if ((styles & DateTimeStyles.AssumeLocal) != DateTimeStyles.None)
{
if ((styles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.None)
{
result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Local);
return true;
}
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = TimeZoneInfo.Local.GetUtcOffset(result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime);
}
else
{
if ((styles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.None)
{
return true;
}
if ((styles & DateTimeStyles.AdjustToUniversal) != DateTimeStyles.None)
{
result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Utc);
return true;
}
result.flags |= ParseFlags.TimeZoneUsed;
result.timeZoneOffset = TimeSpan.Zero;
}
}
if ((styles & DateTimeStyles.RoundtripKind) != DateTimeStyles.None && (result.flags & ParseFlags.TimeZoneUtc) != (ParseFlags)0)
{
result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Utc);
return true;
}
if ((styles & DateTimeStyles.AdjustToUniversal) != DateTimeStyles.None)
{
return DateTimeParse.AdjustTimeZoneToUniversal(ref result);
}
return DateTimeParse.AdjustTimeZoneToLocal(ref result, bTimeOnly);
}
/// <summary>
/// Closes tdate/time selection page
/// </summary>
private void ClosePickerPage()
{
// Unhook from events
if (null != _frame)
{
_frame.Navigated -= OnFrameNavigated;
_frame.NavigationStopped -= OnFrameNavigationStoppedOrFailed;
_frame.NavigationFailed -= OnFrameNavigationStoppedOrFailed;
// Restore host page transitions for the completed "popup" navigation
UIElement frameContentWhenOpenedAsUIElement = _frameContentWhenOpened as UIElement;
if (null != frameContentWhenOpenedAsUIElement)
{
TransitionService.SetNavigationInTransition(frameContentWhenOpenedAsUIElement, _savedNavigationInTransition);
_savedNavigationInTransition = null;
TransitionService.SetNavigationOutTransition(frameContentWhenOpenedAsUIElement, _savedNavigationOutTransition);
_savedNavigationOutTransition = null;
}
_frame = null;
_frameContentWhenOpened = null;
}
// default result
DateTimeResult taskResult = new DateTimeResult(TaskResult.Cancel);
// Commit the value if available
if (null != _dateTimePickerPage)
{
if (_dateTimePickerPage.Value.HasValue)
{
Value = _dateTimePickerPage.Value.Value;
taskResult = new DateTimeResult(TaskResult.OK);
taskResult.Value = Value.Value;
}
_dateTimePickerPage = null;
}
this.Completed(this, taskResult);
}
private static bool DateTimeOffsetTimeZonePostProcessing(ref DateTimeResult result, DateTimeStyles styles)
{
if ((result.flags & ParseFlags.TimeZoneUsed) == (ParseFlags)0)
{
if ((styles & DateTimeStyles.AssumeUniversal) != DateTimeStyles.None)
{
result.timeZoneOffset = TimeSpan.Zero;
}
else
{
result.timeZoneOffset = TimeZoneInfo.Local.GetUtcOffset(result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime);
}
}
long ticks = result.timeZoneOffset.Ticks;
long num = result.parsedDate.Ticks - ticks;
if (num < 0L || num > 3155378975999999999L)
{
result.SetFailure(ParseFailureKind.Format, "Format_UTCOutOfRange", null);
return false;
}
if (ticks < -504000000000L || ticks > 504000000000L)
{
result.SetFailure(ParseFailureKind.Format, "Format_OffsetOutOfRange", null);
return false;
}
if ((styles & DateTimeStyles.AdjustToUniversal) != DateTimeStyles.None)
{
if ((result.flags & ParseFlags.TimeZoneUsed) == (ParseFlags)0 && (styles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.None)
{
bool result2 = DateTimeParse.AdjustTimeZoneToUniversal(ref result);
result.timeZoneOffset = TimeSpan.Zero;
return result2;
}
result.parsedDate = new DateTime(num, DateTimeKind.Utc);
result.timeZoneOffset = TimeSpan.Zero;
}
return true;
}
