/// <summary> /// Determines whether the format string is valid. /// </summary> /// <param name="token">The token to evaluate.</param> /// <returns> /// <c>true</c> if the specified format contains the text; otherwise, <c>false</c>. /// </returns> internal static bool EvaluateFormat(string token) { if ((token == null) || (token == string.Empty)) { return(false); } string str = DefaultTokens.TrimSquareBracket(token); if ((str == null) || (str == string.Empty)) { return(false); } str = str.ToLower(); char ch = '\0'; for (int i = 0; i < str.Length; i++) { if (ch == '\0') { ch = str[i]; } if (((ch != HoursABSContent) && (ch != MinuteABSContent)) && (ch != SecondABSContent)) { return(false); } if (ch != str[i]) { return(false); } } return(true); }
/// <summary> /// Initializes a new instance of the <see cref="T:Dt.Cells.Data.NumberFormatDigital" /> class. /// </summary> /// <param name="format">The format.</param> /// <param name="partLocaleID">The part locale ID.</param> /// <param name="dbNumberFormatPart">The number format part.</param> /// <param name="culture">The culture.</param> public NumberFormatDigital(string format, object partLocaleID, object dbNumberFormatPart, CultureInfo culture) : base(partLocaleID, dbNumberFormatPart, culture) { this.excelFormatString = string.Empty; string s = NumberFormatBase.TrimNotSupportSymbol(format); this.fullFormatString = DefaultTokens.Filter(s, DefaultTokens.LeftSquareBracket, DefaultTokens.RightSquareBracket); this.excelFormatString = s; if (partLocaleID != null) { string str2 = s; s = DefaultTokens.ReplaceKeyword(str2, base.PartLocaleID.OriginalToken, base.PartLocaleID.CurrencySymbol); } if (base.PartDBNumberFormat != null) { this.excelFormatString = DefaultTokens.ReplaceKeyword(this.excelFormatString, base.PartDBNumberFormat.OriginalToken, base.PartDBNumberFormat.ToString()); } s = DefaultTokens.Filter(s, DefaultTokens.LeftSquareBracket, DefaultTokens.RightSquareBracket); if (s.IndexOf(DefaultTokens.SolidusSign) > -1) { s = s.Replace(DefaultTokens.QuestionMark, DefaultTokens.Zero); string[] strArray = DefaultTokens.Split(s, DefaultTokens.SolidusSign); if ((strArray != null) && (strArray.Length == 2)) { this.fractionDenominatorFormat = strArray[1]; string[] integerAndNumeratorParts = this.GetIntegerAndNumeratorParts(strArray[0]); if ((integerAndNumeratorParts != null) && (integerAndNumeratorParts.Length == 3)) { this.fractionIntegerFormat = integerAndNumeratorParts[0]; this.constString = integerAndNumeratorParts[1]; this.fractionNumeratorFormat = integerAndNumeratorParts[2]; } } } this.numberFormatString = s; }
/// <summary> /// Returns a <see cref="T:System.String" /> that represents the current <see cref="T:System.Object" />. /// </summary> /// <returns> /// A <see cref="T:System.String" /> that represents the current <see cref="T:System.Object" />. /// </returns> public override string ToString() { if (this.content != null) { return(DefaultTokens.AddSquareBracket(this.content)); } return(string.Empty); }
/// <summary> /// Returns a <see cref="T:System.String" /> that represents the current <see cref="T:System.Object" />. /// </summary> /// <returns> /// A <see cref="T:System.String" /> that represents the current <see cref="T:System.Object" />. /// </returns> public override string ToString() { if (this.type <= -1) { throw new FormatException(); } return(DefaultTokens.AddSquareBracket("DBNum" + ((int)this.type))); }
/// <summary> /// Fixes the format. /// </summary> /// <param name="format">The format</param> /// <returns>Returns the fixed format string</returns> string FixFormat(string format) { string str = format; StringBuilder builder = new StringBuilder(); bool flag = false; char ch2 = HoursSingleDigit[0]; if (str.IndexOf(((char)ch2).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase) <= -1) { char ch3 = SecondSingleDigit[0]; str.IndexOf(((char)ch3).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase); } char ch4 = YearTwoDigit[0]; if (str.IndexOf(((char)ch4).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase) <= -1) { char ch5 = DaySingleDigit[0]; str.IndexOf(((char)ch5).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase); } for (int i = 0; i < str.Length; i++) { char c = str[i]; if (c == '"') { flag = !flag; } else if (!flag) { switch (c) { case 'Y': case 'D': case 'S': case 'E': case 'G': c = char.ToLower(c); goto Label_010B; } if (c == 'M') { if (i > 1) { if (!DefaultTokens.IsEquals('A', str[i - 1], true) && !DefaultTokens.IsEquals('P', str[i - 1], true)) { c = char.ToLower(c); } } else { c = char.ToLower(c); } } } Label_010B: builder.Append(c); } return(builder.ToString()); }
/// <summary> /// Numbers the string. /// </summary> /// <param name="s">The string to replace</param> /// <param name="dbNumber">The db number</param> /// <param name="isNumber">Indicates whether the number should be formatted by number rules</param> /// <returns>Returns the formatted value</returns> internal string ReplaceNumberString(string s, DBNumber dbNumber, bool isNumber) { if ((s == null) || (s == string.Empty)) { return(s); } string str = s; string str2 = s; int num = -1; int startIndex = -1; bool flag = false; for (int i = s.Length - 1; i >= 0; i--) { char c = str2[i]; if (char.IsNumber(c) || (DefaultTokens.IsEquals(c, DefaultTokens.DecimalSeparator, false) && !flag)) { if (DefaultTokens.IsEquals(c, DefaultTokens.DecimalSeparator, false)) { flag = true; } if (num == -1) { num = i; } startIndex = i; } else if ((startIndex > -1) && (num > -1)) { double num4; string str3 = str2.Substring(startIndex, (num - startIndex) + 1); if (double.TryParse(str3, out num4)) { string str4 = this.NumberString(str3, dbNumber, isNumber); str = str.Remove(startIndex, (num - startIndex) + 1).Insert(startIndex, str4); } num = -1; startIndex = -1; flag = false; } } if ((startIndex > -1) && (num > -1)) { double num5; string str5 = str2.Substring(startIndex, (num - startIndex) + 1); if (double.TryParse(str5, out num5)) { string str6 = this.NumberString(str5, dbNumber, isNumber); str = str.Remove(startIndex, (num - startIndex) + 1).Insert(startIndex, str6); } num = -1; startIndex = -1; flag = false; } return(str); }
/// <summary> /// Determines whether the format string is valid. /// </summary> /// <param name="token">The token to evaluate.</param> /// <returns> /// <c>true</c> if the specified format contains the text; otherwise, <c>false</c>. /// </returns> internal static bool EvaluateFormat(string token) { if ((token == null) || (token == string.Empty)) { return(false); } string str = DefaultTokens.TrimSquareBracket(token); return(((str != null) && !(str == string.Empty)) && DefaultTokens.IsEquals(str[0], DefaultTokens.Dollar, false)); }
/// <summary> /// Returns a <see cref="T:System.String" /> that represents the current <see cref="T:System.Object" />. /// </summary> /// <returns> /// A <see cref="T:System.String" /> that represents the current <see cref="T:System.Object" />. /// </returns> public override string ToString() { if (this.index > -1) { return(DefaultTokens.AddSquareBracket("Color" + ((int)this.index))); } if (this.colorName == null) { throw new FormatException(); } return(DefaultTokens.AddSquareBracket(this.colorName)); }
/// <summary> /// Parses the specified format. /// </summary> /// <param name="s">The string.</param> /// <returns>Returns the value.</returns> public override object Parse(string s) { s = this.TrimSpecialSymbol(s); if ((s != null) && (s != string.Empty)) { bool flag; string str = NumberHelper.FixJapaneseChars(s); if (bool.TryParse(s, out flag)) { return((bool)flag); } bool flag2 = DefaultTokens.IsDecimal(str, this.NumberFormatInfo); bool flag3 = str.IndexOf(DefaultTokens.ExponentialSymbol, (StringComparison)StringComparison.CurrentCultureIgnoreCase) > -1; bool flag4 = (str[0] == DefaultTokens.LeftParenthesis) && (str[str.Length - 1] == DefaultTokens.RightParenthesis); if (this.numberFormatString != null) { double num2; int count = 0; s = this.TrimPercentSign(s, out count); if (this.TryParse(s, out num2, flag3 | flag4)) { if (count > 0) { num2 /= 100.0 * count; } if ((num2 != 0.0) && (Math.Abs((double)(num2 - Math.Floor(num2))) != 0.0)) { flag2 = true; } if (flag3) { flag2 = true; } if (!flag2) { int num3; long num4; if (NumberHelper.TryInteger(num2, out num3)) { return((int)num3); } if (NumberHelper.TryLong(num2, out num4)) { return((long)num4); } } return((double)num2); } } } return(null); }
/// <summary> /// Determines whether the format string is valid. /// </summary> /// <param name="token">The token to evaluate.</param> /// <returns> /// <c>true</c> if the specified format contains the text; otherwise, <c>false</c>. /// </returns> internal static bool EvaluateFormat(string token) { if ((token == null) || (token == string.Empty)) { return(false); } string str = DefaultTokens.TrimSquareBracket(token); if ((str == null) || (str == string.Empty)) { return(false); } return(str.StartsWith("DBNum", (StringComparison)StringComparison.CurrentCultureIgnoreCase)); }
/// <summary> /// Creates a new DB number format. /// </summary> /// <param name="token">The string expression for the format.</param> public DBNumberFormatPart(string token) : base(token) { if (!EvaluateFormat(token)) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } this.token = token; string s = DefaultTokens.TrimSquareBracket(token).Remove(0, "dbnum".Length); this.type = int.Parse(s); if ((this.type < 0) || (this.type > 3)) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } }
/// <summary> /// Initializes a new instance of the <see cref="T:Dt.Cells.Data.NumberFormatText" /> class. /// </summary> /// <param name="format">The format string</param> /// <param name="partLocaleID">The part locale ID.</param> /// <param name="dbNumberFormatPart">The db number format part.</param> /// <param name="culture">The culture.</param> internal NumberFormatText(string format, object partLocaleID, object dbNumberFormatPart, CultureInfo culture) : base(partLocaleID, dbNumberFormatPart, culture) { if (format == null) { throw new ArgumentNullException("format"); } string s = NumberFormatBase.TrimNotSupportSymbol(format, false); if (partLocaleID != null) { s = DefaultTokens.ReplaceKeyword(s, base.PartLocaleID.OriginalToken, base.PartLocaleID.CurrencySymbol); } this.excelFormatString = s; s = DefaultTokens.TrimEscape(DefaultTokens.Filter(s, DefaultTokens.LeftSquareBracket, DefaultTokens.RightSquareBracket)); this.formatString = s; }
/// <summary> /// Creates a new locale format with the specified token. /// </summary> /// <param name="token">The string expression for the format.</param> public LocaleIDFormatPart(string token) : base(token) { this.locateID = -1; if (token == null) { throw new ArgumentNullException("token"); } if (token == string.Empty) { throw new FormatException(ResourceStrings.FormatterIllegaTokenError); } this.content = DefaultTokens.TrimSquareBracket(token); string content = this.content; if ((content == null) || (content == string.Empty)) { throw new FormatException(ResourceStrings.FormatterIllegaTokenError); } if (!DefaultTokens.IsEquals(content[0], DefaultTokens.Dollar, false)) { throw new FormatException(ResourceStrings.FormatterIllegaTokenError); } content = content.Remove(0, 1); int index = content.IndexOf(DefaultTokens.HyphenMinus); if (index > -1) { this.currencySymbol = content.Substring(0, index); content = content.Remove(0, index); } else { this.currencySymbol = content; return; } if (!DefaultTokens.IsEquals(content[0], DefaultTokens.HyphenMinus, false)) { throw new FormatException(ResourceStrings.FormatterIllegaTokenError); } content = content.Remove(0, 1); if (content.Length <= 0) { throw new FormatException(ResourceStrings.FormatterIllegaTokenError); } this.locateID = NumberHelper.ParseHexString(content); }
/// <summary> /// Determines whether the format string is valid. /// </summary> /// <param name="token">The token to evaluate.</param> /// <returns> /// <c>true</c> if the specified format contains the text; otherwise, <c>false</c>. /// </returns> internal static bool EvaluateFormat(string token) { if ((token == null) || (token == string.Empty)) { return(false); } string str = DefaultTokens.TrimSquareBracket(token); if ((str == null) || (str == string.Empty)) { return(false); } if (str.Length < 3) { return(false); } if (char.IsNumber(token[token.Length - 1])) { return(token.StartsWith("Color", (StringComparison)StringComparison.CurrentCultureIgnoreCase)); } return(token[0] != token[1]); }
/// <summary> /// Parses the specified string. /// </summary> /// <param name="s">The string.</param> /// <returns>Returns the parsed object.</returns> public object Parse(string s) { if ((s != null) && (s != string.Empty)) { if (DefaultTokens.IsDecimal(s, this.FormatProvider)) { double num; if (double.TryParse(s, (NumberStyles)NumberStyles.Any, (IFormatProvider)this.FormatProvider, out num)) { return((double)num); } } else { int num2; if (int.TryParse(s, (NumberStyles)NumberStyles.Any, (IFormatProvider)this.FormatProvider, out num2)) { return((int)num2); } } } return(null); }
/// <summary> /// Creates a new color format. /// </summary> /// <param name="token">The string expression for the color format.</param> /// <remarks>Use a string expression such as "[red]" or "[blue]" to specify the color format.</remarks> public ColorFormatPart(string token) : base(token) { this.foreColor = Colors.Black; this.index = -1; string color = DefaultTokens.TrimSquareBracket(token); if ((color == null) || (color == string.Empty)) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } try { Windows.UI.Color?nullable = FormatterColorHelper.FromStringValue(color); if (nullable.HasValue) { this.foreColor = nullable.Value; this.colorName = color; return; } if (color.Length > "Color".Length) { color = color.Remove(0, "Color".Length); int result = -1; if ((int.TryParse(color, out result) && (result >= 1)) && (result <= 0x38)) { this.foreColor = FormatterColorHelper.ColorFromIndex(result); this.index = result; return; } } } catch { } throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); }
/// <summary> /// Returns a string that represents the current conditional format. /// </summary> /// <returns> /// A <see cref="T:System.String" /> that represents the current <see cref="T:Dt.Cells.Data.ConditionFormatPart" /> object. /// </returns> public override string ToString() { StringBuilder builder = new StringBuilder(); switch (this.compareOperator) { case GeneralCompareType.EqualsTo: builder.Append("="); break; case GeneralCompareType.NotEqualsTo: builder.Append("<>"); break; case GeneralCompareType.GreaterThan: builder.Append(">"); break; case GeneralCompareType.GreaterThanOrEqualsTo: builder.Append(">="); break; case GeneralCompareType.LessThan: builder.Append("<"); break; case GeneralCompareType.LessThanOrEqualsTo: builder.Append("<="); break; default: throw new FormatException(); } builder.Append(this.value); return(DefaultTokens.AddSquareBracket(builder.ToString())); }
/// <summary> /// Formats the specified value. /// </summary> /// <param name="obj">The object.</param> /// <returns> /// Returns the string of the formatted value. /// </returns> public override string Format(object obj) { string str = string.Empty; if (FormatConverter.IsNumber(obj)) { bool flag = (base.PartLocaleID == null) || base.PartLocaleID.AllowScience; double?nullable = FormatConverter.TryDouble(obj, true); if (!nullable.HasValue) { return(""); } double num = nullable.Value; if (((Math.Abs(num) <= 99999999999) || !flag) && ((Math.Abs(num) >= 1E-11) || (num == 0.0))) { return(this.DigitalFormat.Format(obj)); } return(this.ExponentialDigitalFormat.Format(obj)); } if (obj is string) { string newValue = FormatConverter.ToString(obj, true); string str3 = DefaultTokens.TrimEscape(this.FormatString.Replace("\"", "")); if (str3 != null) { newValue = str3.Replace("General", newValue); } return(newValue); } if (obj is bool) { bool flag2 = (bool)((bool)obj); str = flag2.ToString().ToUpper(); } return(str); }
/// <summary> /// Parses the specified format. /// </summary> /// <param name="s">The string.</param> /// <returns>Returns the value.</returns> public override object Parse(string s) { if ((s == null) || (s == string.Empty)) { return(null); } s = NumberHelper.FixJapaneseChars(s); bool flag = false; int index = s.IndexOf("-"); if ((index > 0) && !DefaultTokens.IsEquals(s[index - 1], DefaultTokens.ExponentialSymbol, true)) { flag = true; } List <string> list = new List <string>(new string[] { "/", ":", "." }); list.Remove(CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator); bool flag2 = false; if (flag) { flag2 = true; } if (!flag2) { foreach (string str in list) { if (s.Contains(str)) { flag2 = true; break; } } } if (flag2) { DateTime time; if (DateTime.TryParseExact(s, GeneralMonthDay, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } if (DateTime.TryParseExact(s, generalYearMonth, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } if (DateTime.TryParseExact(s, GeneralYearMonthDay, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } if (DateTime.TryParseExact(s, AlternativeYearMonthDay, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } if (DateTime.TryParseExact(s, generalHourMinute, null, ((DateTimeStyles)DateTimeStyles.NoCurrentDateDefault) | ((DateTimeStyles)DateTimeStyles.AllowWhiteSpaces), out time)) { if (((time.Year == 1) && (time.Month == 1)) && (time.Day == 1)) { return(new TimeSpan(0, time.Hour, time.Minute, time.Second, time.Millisecond)); } return(time); } if (DateTime.TryParseExact(s, generalHourMinuteSecond, null, ((DateTimeStyles)DateTimeStyles.NoCurrentDateDefault) | ((DateTimeStyles)DateTimeStyles.AllowWhiteSpaces), out time)) { if (((time.Year == 1) && (time.Month == 1)) && (time.Day == 1)) { return(new TimeSpan(0, time.Hour, time.Minute, time.Second, time.Millisecond)); } return(time); } if (DateTime.TryParseExact(s, generalHourMinuteSecondSubSecond, null, ((DateTimeStyles)DateTimeStyles.NoCurrentDateDefault) | ((DateTimeStyles)DateTimeStyles.AllowWhiteSpaces), out time)) { if (((time.Year == 1) && (time.Month == 1)) && (time.Day == 1)) { return(new TimeSpan(0, time.Hour, time.Minute, time.Second, time.Millisecond)); } return(time); } if (DateTime.TryParseExact(s, GeneralHourMinuteWithDate, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } if (DateTime.TryParseExact(s, GeneralHourMinuteSecondWithDate, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } if (DateTime.TryParseExact(s, GeneralHourMinuteSecondSubSecondWithDate, null, (DateTimeStyles)DateTimeStyles.AllowWhiteSpaces, out time)) { return(time); } } string str2 = s; bool? nullable = null; if (str2.Substring(0, 1) == DefaultTokens.NegativeSign) { nullable = true; } else if (str2.Substring(0, 1) == DefaultTokens.PositiveSign) { nullable = false; } bool flag3 = false; if ((nullable.HasValue && (str2.Length > 3)) && ((str2[1] == DefaultTokens.LeftParenthesis) && (str2[str2.Length - 1] == DefaultTokens.RightParenthesis))) { flag3 = true; } if (nullable.HasValue && flag3) { string str3 = s.Remove(0, 1); object obj2 = this.DigitalFormat.Parse(str3); if (obj2 == null) { return(s); } if (obj2 is double) { if (nullable.Value) { return((double)-Math.Abs((double)((double)obj2))); } return((double)Math.Abs((double)((double)obj2))); } if (!(obj2 is int)) { return(obj2); } if (nullable.Value) { return((int)-Math.Abs((int)((int)obj2))); } return((int)Math.Abs((int)((int)obj2))); } object obj3 = this.DigitalFormat.Parse(s); if (obj3 != null) { return(obj3); } return(s); }
/// <summary> /// Creates a new condition format with the specified string expression. /// </summary> /// <param name="token">The string expression for this format.</param> /// <remarks>Examples of conditional string expressions are "[>10]" and "[>=0]".</remarks> public ConditionFormatPart(string token) : base(token) { string str = DefaultTokens.TrimSquareBracket(token); if (string.IsNullOrEmpty(str)) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } StringBuilder builder = null; int num = 0; while (num < str.Length) { char c = str[num]; if (!DefaultTokens.IsOperator(c)) { break; } if (builder == null) { builder = new StringBuilder(); } builder.Append(c); num++; } if (builder == null) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } string str2 = builder.ToString(); builder = null; switch (str2) { case "<": this.compareOperator = GeneralCompareType.LessThan; break; case "<=": this.compareOperator = GeneralCompareType.LessThanOrEqualsTo; break; case "=": this.compareOperator = GeneralCompareType.EqualsTo; break; case ">=": this.compareOperator = GeneralCompareType.GreaterThanOrEqualsTo; break; case ">": this.compareOperator = GeneralCompareType.GreaterThan; break; case "<>": this.compareOperator = GeneralCompareType.NotEqualsTo; break; default: throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } while (num < str.Length) { char ch2 = str[num]; if (DefaultTokens.IsOperator(ch2)) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } if (builder == null) { builder = new StringBuilder(); } builder.Append(ch2); num++; } if (builder == null) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } if (!double.TryParse(builder.ToString(), out this.value)) { throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError); } }
/// <summary> /// Replaces the specified format. /// </summary> /// <param name="format">The format</param> /// <param name="oldToken">The old token</param> /// <param name="newToken">The new token</param> /// <param name="isReplaceInDateFormat">if set to <c>true</c> should replace token in date area</param> /// <param name="isReplaceInTimeFormat">if set to <c>true</c> should replace token in time area</param> /// <param name="result">The result.</param> /// <param name="justSearch">if set to <c>true</c> not really replace.</param> /// <param name="isIgnoreCase">if set to <c>true</c> is ignore case.</param> /// <returns> /// <c>true</c> if replace token successful; otherwise, <c>false</c>. /// </returns> bool Replace(string format, string oldToken, string newToken, bool isReplaceInDateFormat, bool isReplaceInTimeFormat, out string result, bool justSearch, bool isIgnoreCase) { result = format; if (!isReplaceInDateFormat && !isReplaceInTimeFormat) { return(false); } List <int> list = new List <int>(); bool flag = true; char ch3 = HoursSingleDigit[0]; bool flag2 = (result.IndexOf(((char)ch3).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase) > -1) || (result.IndexOf(((char)SecondSingleDigit[0]).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase) > -1); char ch5 = YearTwoDigit[0]; if (((result.IndexOf(((char)ch5).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase) <= -1) && (result.IndexOf(((char)DaySingleDigit[0]).ToString(), (StringComparison)StringComparison.CurrentCultureIgnoreCase) <= -1)) && flag2) { flag = false; } bool flag4 = false; int num = 0; for (int i = 0; i < result.Length; i++) { char a = result[i]; if (DefaultTokens.IsEquals(a, HoursSingleDigit[0], true) || DefaultTokens.IsEquals(a, SecondSingleDigit[0], true)) { flag = false; } else if (DefaultTokens.IsEquals(a, YearTwoDigit[0], true) || DefaultTokens.IsEquals(a, DaySingleDigit[0], true)) { flag = true; } if (((isReplaceInDateFormat && DefaultTokens.IsEquals(a, oldToken[num], isIgnoreCase)) && flag) || ((isReplaceInTimeFormat && DefaultTokens.IsEquals(a, oldToken[num], isIgnoreCase)) && !flag)) { bool flag5 = true; for (int j = 0; j < oldToken.Length; j++) { if (((j + i) >= format.Length) || !DefaultTokens.IsEquals(oldToken[j], result[j + i], isIgnoreCase)) { flag5 = false; break; } } int num4 = (i + oldToken.Length) - 1; if (flag5 && ((num4 + 1) < result.Length)) { char ch2 = result[num4]; int num5 = -1; num5 = num4 + 1; while (num5 < result.Length) { if (!DefaultTokens.IsEquals(ch2, result[num5], isIgnoreCase)) { break; } num5++; } if (num5 > (num4 + 1)) { i = num5; flag5 = false; } } if (flag5 && !flag4) { list.Insert(0, i); } } if (a == '"') { flag4 = !flag4; } } if (list.Count <= 0) { return(false); } if (!justSearch) { foreach (int num6 in list) { result = result.Remove(num6, oldToken.Length); result = result.Insert(num6, newToken); } } return(true); }