We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Globalization \ DateTimeFormatInfoScanner

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. ////////////////////////////////////////////////////////////////////////////
  16. //
  17. // DateTimeFormatInfoScanner
  18. //
  19. // Scan a specified DateTimeFormatInfo to search for data used in DateTime.Parse()
  20. //
  21. // The data includes:
  22. //
  23. // DateWords: such as "de" used in es-ES (Spanish) LongDatePattern.
  24. // Postfix: such as "ta" used in fi-FI after the month name.
  25. //
  26. ////////////////////////////////////////////////////////////////////////////
  28. namespace System.Globalization
  29. {
  30.     using System;
  31.     using System.Globalization;
  32.     using System.Collections;
  33.     using System.Text;
  34.    
  35.     //
  36.     // from LocaleEx.txt header
  37.     //
  38.     //; IFORMATFLAGS
  39.     //; Parsing/formatting flags.
  40.     internal enum FORMATFLAGS
  41.     {
  42.         None = 0,
  43.         UseGenitiveMonth = 1,
  44.         UseLeapYearMonth = 2,
  45.         UseSpacesInMonthNames = 4,
  46.         UseHebrewParsing = 8,
  47.         UseSpacesInDayNames = 16,
  48.         // Has spaces or non-breaking space in the day names.
  49.         UseDigitPrefixInTokens = 32
  50.         // Has token starting with numbers.
  51.     }
  52.    
  53.     //
  54.     // To change in CalendarId you have to do the same change in Calendar.cs
  55.     // To do: make the definintion shared between these two files.
  56.     //
  57.    
  58.     internal enum CalendarId : ushort
  59.     {
  60.         GREGORIAN = 1,
  61.         // Gregorian (localized) calendar
  62.         GREGORIAN_US = 2,
  63.         // Gregorian (U.S.) calendar
  64.         JAPAN = 3,
  65.         // Japanese Emperor Era calendar
  66.         TAIWAN = 4,
  67.         // Taiwan Era calendar
  68.         KOREA = 5,
  69.         // Korean Tangun Era calendar
  70.         HIJRI = 6,
  71.         // Hijri (Arabic Lunar) calendar
  72.         THAI = 7,
  73.         // Thai calendar
  74.         HEBREW = 8,
  75.         // Hebrew (Lunar) calendar
  76.         GREGORIAN_ME_FRENCH = 9,
  77.         // Gregorian Middle East French calendar
  78.         GREGORIAN_ARABIC = 10,
  79.         // Gregorian Arabic calendar
  80.         GREGORIAN_XLIT_ENGLISH = 11,
  81.         // Gregorian Transliterated English calendar
  82.         GREGORIAN_XLIT_FRENCH = 12,
  83.         // Note that all calendars after this point are MANAGED ONLY for now.
  84.         JULIAN = 13,
  85.         JAPANESELUNISOLAR = 14,
  86.         CHINESELUNISOLAR = 15,
  87.         SAKA = 16,
  88.         // reserved to match Office but not implemented in our code
  89.         LUNAR_ETO_CHN = 17,
  90.         // reserved to match Office but not implemented in our code
  91.         LUNAR_ETO_KOR = 18,
  92.         // reserved to match Office but not implemented in our code
  93.         LUNAR_ETO_ROKUYOU = 19,
  94.         // reserved to match Office but not implemented in our code
  95.         KOREANLUNISOLAR = 20,
  96.         TAIWANLUNISOLAR = 21,
  97.         PERSIAN = 22,
  98.         UMALQURA = 23
  99.     }
  100.    
  101.     internal class DateTimeFormatInfoScanner
  102.     {
  103.         // Special prefix-like flag char in DateWord array.
  104.        
  105.         // Use char in PUA area since we won't be using them in real data.
  106.         // The char used to tell a read date word or a month postfix. A month postfix
  107.         // is "ta" in the long date pattern like "d. MMMM'ta 'yyyy" for fi-FI.
  108.         // In this case, it will be stored as "\xfffeta" in the date word array.
  109.         internal const char MonthPostfixChar = '';
  110.        
  111.         // Add ignorable symbol in a DateWord array.
  112.        
  113.         // hu-HU has:
  114.         // shrot date pattern: yyyy. MM. dd.;yyyy-MM-dd;yy-MM-dd
  115.         // long date pattern: yyyy. MMMM d.
  116.         // Here, "." is the date separator (derived from short date pattern). However,
  117.         // "." also appear at the end of long date pattern. In this case, we just
  118.         // "." as ignorable symbol so that the DateTime.Parse() state machine will not
  119.         // treat the additional date separator at the end of y,m,d pattern as an error
  120.         // condition.
  121.         internal const char IgnorableSymbolChar = '';
  122.        
  123.         // Known CJK suffix
  124.         internal const string CJKYearSuff = "年";
  125.         internal const string CJKMonthSuff = "月";
  126.         internal const string CJKDaySuff = "日";
  127.        
  128.         internal const string KoreanYearSuff = "년";
  129.         internal const string KoreanMonthSuff = "월";
  130.         internal const string KoreanDaySuff = "일";
  131.        
  132.         internal const string KoreanHourSuff = "시";
  133.         internal const string KoreanMinuteSuff = "분";
  134.         internal const string KoreanSecondSuff = "초";
  135.        
  136.         internal const string CJKHourSuff = "時";
  137.         internal const string ChineseHourSuff = "时";
  138.        
  139.         internal const string CJKMinuteSuff = "分";
  140.         internal const string CJKSecondSuff = "秒";
  141.        
  142.         // The collection fo date words & postfix.
  143.         internal ArrayList m_dateWords = new ArrayList();
  144.         // Hashtable for the known words.
  145.         static internal Hashtable m_knownWords;
  146.        
  147.         Hashtable KnownWords {
  148.             get {
  149.                 if (m_knownWords == null) {
  150.                     Hashtable temp = new Hashtable();
  151.                     // Add known words into the hash table.
  152.                    
  153.                     // Skip these special symbols.
  154.                     temp.Add("/", String.Empty);
  155.                     temp.Add("-", String.Empty);
  156.                     temp.Add(".", String.Empty);
  157.                     // Skip known CJK suffixes.
  158.                     temp.Add(CJKYearSuff, String.Empty);
  159.                     temp.Add(CJKMonthSuff, String.Empty);
  160.                     temp.Add(CJKDaySuff, String.Empty);
  161.                     temp.Add(KoreanYearSuff, String.Empty);
  162.                     temp.Add(KoreanMonthSuff, String.Empty);
  163.                     temp.Add(KoreanDaySuff, String.Empty);
  164.                     temp.Add(KoreanHourSuff, String.Empty);
  165.                     temp.Add(KoreanMinuteSuff, String.Empty);
  166.                     temp.Add(KoreanSecondSuff, String.Empty);
  167.                     temp.Add(CJKHourSuff, String.Empty);
  168.                     temp.Add(ChineseHourSuff, String.Empty);
  169.                     temp.Add(CJKMinuteSuff, String.Empty);
  170.                     temp.Add(CJKSecondSuff, String.Empty);
  171.                    
  172.                     m_knownWords = temp;
  173.                 }
  174.                 return (m_knownWords);
  175.             }
  176.         }
  177.        
  178.         ////////////////////////////////////////////////////////////////////////////
  179.         //
  180.         // Parameters:
  181.         // pattern: The pattern to be scanned.
  182.         // currentIndex: the current index to start the scan.
  183.         //
  184.         // Returns:
  185.         // Return the index with the first character that is a letter, which will
  186.         // be the start of a date word.
  187.         // Note that the index can be pattern.Length if we reach the end of the string.
  188.         //
  189.         ////////////////////////////////////////////////////////////////////////////
  190.         static internal int SkipWhiteSpacesAndNonLetter(string pattern, int currentIndex)
  191.         {
  192.             while (currentIndex < pattern.Length) {
  193.                 char ch = pattern[currentIndex];
  194.                 if (ch == '\\') {
  195.                     // Escaped character. Look ahead one character.
  196.                     currentIndex++;
  197.                     if (currentIndex < pattern.Length) {
  198.                         ch = pattern[currentIndex];
  199.                         if (ch == '\'') {
  200.                             // Skip the leading single quote. We will
  201.                             // stop at the first letter.
  202.                             continue;
  203.                         }
  204.                         // Fall thru to check if this is a letter.
  205.                     }
  206.                     else {
  207.                         // End of string
  208.                         break;
  209.                     }
  210.                 }
  211.                 if (Char.IsLetter(ch) || ch == '\'' || ch == '.') {
  212.                     break;
  213.                 }
  214.                 // Skip the current char since it is not a letter.
  215.                 currentIndex++;
  216.             }
  217.             return (currentIndex);
  218.         }
  219.        
  220.         ////////////////////////////////////////////////////////////////////////////
  221.         //
  222.         // A helper to add the found date word or month postfix into ArrayList for date words.
  223.         //
  224.         // Parameters:
  225.         // formatPostfix: What kind of postfix this is.
  226.         // Possible values:
  227.         // null: This is a regular date word
  228.         // "MMMM": month postfix
  229.         // word: The date word or postfix to be added.
  230.         //
  231.         ////////////////////////////////////////////////////////////////////////////
  232.         internal void AddDateWordOrPostfix(string formatPostfix, string str)
  233.         {
  234.             if (str.Length > 0) {
  235.                 // Some cultures use . like an abbreviation
  236.                 if (str.Equals(".")) {
  237.                     AddIgnorableSymbols(".");
  238.                     return;
  239.                 }
  240.                 if (KnownWords[str] == null) {
  241.                     if (m_dateWords == null) {
  242.                         m_dateWords = new ArrayList();
  243.                     }
  244.                     if (formatPostfix == "MMMM") {
  245.                         // Add the word into the ArrayList as "\xfffe" + real month postfix.
  246.                         string temp = MonthPostfixChar + str;
  247.                         if (!m_dateWords.Contains(temp)) {
  248.                             m_dateWords.Add(temp);
  249.                         }
  250.                     }
  251.                     else {
  252.                         if (!m_dateWords.Contains(str)) {
  253.                             m_dateWords.Add(str);
  254.                         }
  255.                         if (str[str.Length - 1] == '.') {
  256.                             // Old version ignore the trialing dot in the date words. Support this as well.
  257.                             string strWithoutDot = str.Substring(0, str.Length - 1);
  258.                             if (!m_dateWords.Contains(strWithoutDot)) {
  259.                                 m_dateWords.Add(strWithoutDot);
  260.                             }
  261.                            
  262.                         }
  263.                     }
  264.                 }
  265.             }
  266.            
  267.         }
  268.        
  269.         ////////////////////////////////////////////////////////////////////////////
  270.         //
  271.         // Scan the pattern from the specified index and add the date word/postfix
  272.         // when appropriate.
  273.         //
  274.         // Parameters:
  275.         // pattern: The pattern to be scanned.
  276.         // index: The starting index to be scanned.
  277.         // formatPostfix: The kind of postfix to be scanned.
  278.         // Possible values:
  279.         // null: This is a regular date word
  280.         // "MMMM": month postfix
  281.         //
  282.         //
  283.         ////////////////////////////////////////////////////////////////////////////
  284.         internal int AddDateWords(string pattern, int index, string formatPostfix)
  285.         {
  286.             // Skip any whitespaces so we will start from a letter.
  287.             int newIndex = SkipWhiteSpacesAndNonLetter(pattern, index);
  288.             if (newIndex != index && formatPostfix != null) {
  289.                 // There are whitespaces. This will not be a postfix.
  290.                 formatPostfix = null;
  291.             }
  292.             index = newIndex;
  293.            
  294.             // This is the first char added into dateWord.
  295.             // Skip all non-letter character. We will add the first letter into DateWord.
  296.             StringBuilder dateWord = new StringBuilder();
  297.             // We assume that date words should start with a letter.
  298.             // Skip anything until we see a letter.
  299.            
  300.             while (index < pattern.Length) {
  301.                 char ch = pattern[index];
  302.                 if (ch == '\'') {
  303.                     // We have seen the end of quote. Add the word if we do not see it before,
  304.                     // and break the while loop.
  305.                     AddDateWordOrPostfix(formatPostfix, dateWord.ToString());
  306.                     index++;
  307.                     break;
  308.                 }
  309.                 else if (ch == '\\') {
  310.                     //
  311.                     // Escaped character. Look ahead one character
  312.                     //
  313.                    
  314.                     // Skip escaped backslash.
  315.                     index++;
  316.                     if (index < pattern.Length) {
  317.                         dateWord.Append(pattern[index]);
  318.                         index++;
  319.                     }
  320.                 }
  321.                 else if (Char.IsWhiteSpace(ch)) {
  322.                     // Found a whitespace. We have to add the current date word/postfix.
  323.                     AddDateWordOrPostfix(formatPostfix, dateWord.ToString());
  324.                     if (formatPostfix != null) {
  325.                         // Done with postfix. The rest will be regular date word.
  326.                         formatPostfix = null;
  327.                     }
  328.                     // Reset the dateWord.
  329.                     dateWord.Length = 0;
  330.                     index++;
  331.                 }
  332.                 else {
  333.                     dateWord.Append(ch);
  334.                     index++;
  335.                 }
  336.             }
  337.             return (index);
  338.         }
  339.        
  340.         ////////////////////////////////////////////////////////////////////////////
  341.         //
  342.         // A simple helper to find the repeat count for a specified char.
  343.         //
  344.         ////////////////////////////////////////////////////////////////////////////
  345.         static internal int ScanRepeatChar(string pattern, char ch, int index, out int count)
  346.         {
  347.             count = 1;
  348.             while (++index < pattern.Length && pattern[index] == ch) {
  349.                 count++;
  350.             }
  351.             // Return the updated position.
  352.             return (index);
  353.         }
  354.        
  355.         ////////////////////////////////////////////////////////////////////////////
  356.         //
  357.         // Add the text that is a date separator but is treated like ignroable symbol.
  358.         // E.g.
  359.         // hu-HU has:
  360.         // shrot date pattern: yyyy. MM. dd.;yyyy-MM-dd;yy-MM-dd
  361.         // long date pattern: yyyy. MMMM d.
  362.         // Here, "." is the date separator (derived from short date pattern). However,
  363.         // "." also appear at the end of long date pattern. In this case, we just
  364.         // "." as ignorable symbol so that the DateTime.Parse() state machine will not
  365.         // treat the additional date separator at the end of y,m,d pattern as an error
  366.         // condition.
  367.         //
  368.         ////////////////////////////////////////////////////////////////////////////
  369.        
  370.         internal void AddIgnorableSymbols(string text)
  371.         {
  372.             if (m_dateWords == null) {
  373.                 // Create the date word array.
  374.                 m_dateWords = new ArrayList();
  375.             }
  376.             // Add the ingorable symbol into the ArrayList.
  377.             string temp = IgnorableSymbolChar + text;
  378.             if (!m_dateWords.Contains(temp)) {
  379.                 m_dateWords.Add(temp);
  380.             }
  381.         }
  382.        
  383.        
  384.         //
  385.         // Flag used to trace the date patterns (yy/yyyyy/M/MM/MMM/MMM/d/dd) that we have seen.
  386.         //
  387.         enum FoundDatePattern
  388.         {
  389.             None = 0,
  390.             FoundYearPatternFlag = 1,
  391.             FoundMonthPatternFlag = 2,
  392.             FoundDayPatternFlag = 4,
  393.             FoundYMDPatternFlag = 7
  394.             // FoundYearPatternFlag | FoundMonthPatternFlag | FoundDayPatternFlag;
  395.         }
  396.        
  397.         // Check if we have found all of the year/month/day pattern.
  398.         FoundDatePattern m_ymdFlags = FoundDatePattern.None;
  399.        
  400.        
  401.         ////////////////////////////////////////////////////////////////////////////
  402.         //
  403.         // Given a date format pattern, scan for date word or postfix.
  404.         //
  405.         // A date word should be always put in a single quoted string. And it will
  406.         // start from a letter, so whitespace and symbols will be ignored before
  407.         // the first letter.
  408.         //
  409.         // Examples of date word:
  410.         // 'de' in es-SP: dddd, dd' de 'MMMM' de 'yyyy
  411.         // "\x0443." in bg-BG: dd.M.yyyy '\x0433.'
  412.         //
  413.         // Example of postfix:
  414.         // month postfix:
  415.         // "ta" in fi-FI: d. MMMM'ta 'yyyy
  416.         // Currently, only month postfix is supported.
  417.         //
  418.         // Usage:
  419.         // Always call this with Framework-style pattern, instead of Windows style pattern.
  420.         // Windows style pattern uses '' for single quote, while .NET uses \'
  421.         //
  422.         ////////////////////////////////////////////////////////////////////////////
  423.         internal void ScanDateWord(string pattern)
  424.         {
  425.            
  426.             // Check if we have found all of the year/month/day pattern.
  427.             m_ymdFlags = FoundDatePattern.None;
  428.            
  429.             int i = 0;
  430.             while (i < pattern.Length) {
  431.                 char ch = pattern[i];
  432.                 int chCount;
  433.                
  434.                 switch (ch) {
  435.                     case '\'':
  436.                         // Find a beginning quote. Search until the end quote.
  437.                         i = AddDateWords(pattern, i + 1, null);
  438.                         break;
  439.                     case 'M':
  440.                         i = ScanRepeatChar(pattern, 'M', i, out chCount);
  441.                         if (chCount >= 4) {
  442.                             if (i < pattern.Length && pattern[i] == '\'') {
  443.                                 i = AddDateWords(pattern, i + 1, "MMMM");
  444.                             }
  445.                         }
  447.                         m_ymdFlags |= FoundDatePattern.FoundMonthPatternFlag;
  448.                         break;
  449.                     case 'y':
  450.                         i = ScanRepeatChar(pattern, 'y', i, out chCount);
  451.                         m_ymdFlags |= FoundDatePattern.FoundYearPatternFlag;
  452.                         break;
  453.                     case 'd':
  454.                         i = ScanRepeatChar(pattern, 'd', i, out chCount);
  455.                         if (chCount <= 2) {
  456.                             // Only count "d" & "dd".
  457.                             // ddd, dddd are day names. Do not count them.
  458.                             m_ymdFlags |= FoundDatePattern.FoundDayPatternFlag;
  459.                         }
  461.                         break;
  462.                     case '\\':
  463.                         // Found a escaped char not in a quoted string. Skip the current backslash
  464.                         // and its next character.
  465.                         i += 2;
  466.                         break;
  467.                     case '.':
  468.                         if (m_ymdFlags == FoundDatePattern.FoundYMDPatternFlag) {
  469.                             // If we find a dot immediately after the we have seen all of the y, m, d pattern.
  470.                             // treat it as a ignroable symbol. Check for comments in AddIgnorableSymbols for
  471.                             // more details.
  472.                             AddIgnorableSymbols(".");
  473.                             m_ymdFlags = FoundDatePattern.None;
  474.                         }
  476.                         i++;
  477.                         break;
  478.                     default:
  479.                         if (m_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !Char.IsWhiteSpace(ch)) {
  480.                             // We are not seeing "." after YMD. Clear the flag.
  481.                             m_ymdFlags = FoundDatePattern.None;
  482.                         }
  484.                         // We are not in quote. Skip the current character.
  485.                         i++;
  486.                         break;
  487.                 }
  488.             }
  489.         }
  490.        
  491.         ////////////////////////////////////////////////////////////////////////////
  492.         //
  493.         // Given a DTFI, get all of the date words.
  494.         //
  495.         ////////////////////////////////////////////////////////////////////////////
  496.        
  497.         internal string[] GetDateWordsOfDTFI(DateTimeFormatInfo dtfi)
  498.         {
  499.             // Enumarate all LongDatePatterns, and get the DateWords and scan for month postfix.
  500.             string[] datePatterns = dtfi.GetAllDateTimePatterns('D');
  501.             int i;
  502.             for (i = 0; i < datePatterns.Length; i++) {
  503.                 ScanDateWord(datePatterns[i]);
  504.             }
  505.             datePatterns = dtfi.GetAllDateTimePatterns('d');
  506.             for (i = 0; i < datePatterns.Length; i++) {
  507.                 ScanDateWord(datePatterns[i]);
  508.             }
  509.             // Scan the YearMonth patterns.
  510.             datePatterns = dtfi.GetAllDateTimePatterns('y');
  511.             for (i = 0; i < datePatterns.Length; i++) {
  512.                 ScanDateWord(datePatterns[i]);
  513.             }
  514.             string[] result = null;
  515.             if (m_dateWords != null && m_dateWords.Count > 0) {
  516.                 result = new string[m_dateWords.Count];
  517.                 for (i = 0; i < m_dateWords.Count; i++) {
  518.                     result[i] = (string)m_dateWords[i];
  519.                 }
  520.             }
  521.             return (result);
  522.         }
  523.        
  524.        
  525.         ////////////////////////////////////////////////////////////////////////////
  526.         //
  527.         // Scan the month names to see if genitive month names are used, and return
  528.         // the format flag.
  529.         //
  530.         ////////////////////////////////////////////////////////////////////////////
  531.         static internal FORMATFLAGS GetFormatFlagGenitiveMonth(string[] monthNames, string[] genitveMonthNames, string[] abbrevMonthNames, string[] genetiveAbbrevMonthNames)
  532.         {
  533.             // If we have different names in regular and genitive month names, use genitive month flag.
  534.             return ((!EqualStringArrays(monthNames, genitveMonthNames) || !EqualStringArrays(abbrevMonthNames, genetiveAbbrevMonthNames)) ? FORMATFLAGS.UseGenitiveMonth : 0);
  535.         }
  536.        
  537.         ////////////////////////////////////////////////////////////////////////////
  538.         //
  539.         // Scan the month names to see if spaces are used or start with a digit, and return the format flag
  540.         //
  541.         ////////////////////////////////////////////////////////////////////////////
  542.         static internal FORMATFLAGS GetFormatFlagUseSpaceInMonthNames(string[] monthNames, string[] genitveMonthNames, string[] abbrevMonthNames, string[] genetiveAbbrevMonthNames)
  543.         {
  544.             FORMATFLAGS formatFlags = 0;
  545.             formatFlags |= (ArrayElementsBeginWithDigit(monthNames) || ArrayElementsBeginWithDigit(genitveMonthNames) || ArrayElementsBeginWithDigit(abbrevMonthNames) || ArrayElementsBeginWithDigit(genetiveAbbrevMonthNames) ? FORMATFLAGS.UseDigitPrefixInTokens : 0);
  546.            
  547.             formatFlags |= (ArrayElementsHaveSpace(monthNames) || ArrayElementsHaveSpace(genitveMonthNames) || ArrayElementsHaveSpace(abbrevMonthNames) || ArrayElementsHaveSpace(genetiveAbbrevMonthNames) ? FORMATFLAGS.UseSpacesInMonthNames : 0);
  548.             return (formatFlags);
  549.         }
  550.        
  551.         ////////////////////////////////////////////////////////////////////////////
  552.         //
  553.         // Scan the day names and set the correct format flag.
  554.         //
  555.         ////////////////////////////////////////////////////////////////////////////
  556.         static internal FORMATFLAGS GetFormatFlagUseSpaceInDayNames(string[] dayNames, string[] abbrevDayNames)
  557.         {
  558.             return ((ArrayElementsHaveSpace(dayNames) || ArrayElementsHaveSpace(abbrevDayNames)) ? FORMATFLAGS.UseSpacesInDayNames : 0);
  559.            
  560.         }
  561.        
  562.         ////////////////////////////////////////////////////////////////////////////
  563.         //
  564.         // Check the calendar to see if it is HebrewCalendar and set the Hebrew format flag if necessary.
  565.         //
  566.         ////////////////////////////////////////////////////////////////////////////
  567.         static internal FORMATFLAGS GetFormatFlagUseHebrewCalendar(int calID)
  568.         {
  569.             return (calID == (int)CalendarId.HEBREW ? FORMATFLAGS.UseHebrewParsing | FORMATFLAGS.UseLeapYearMonth : 0);
  570.         }
  571.        
  572.        
  573.         //-----------------------------------------------------------------------------
  574.         // EqualStringArrays
  575.         // compares two string arrays and return true if all elements of the first
  576.         // array equals to all elmentsof the second array.
  577.         // otherwise it returns false.
  578.         //-----------------------------------------------------------------------------
  579.        
  580.         private static bool EqualStringArrays(string[] array1, string[] array2)
  581.         {
  582.             if (array1.Length != array2.Length) {
  583.                 return false;
  584.             }
  585.            
  586.             for (int i = 0; i < array1.Length; i++) {
  587.                 if (!array1[i].Equals(array2[i])) {
  588.                     return false;
  589.                 }
  590.             }
  591.            
  592.             return true;
  593.         }
  594.        
  595.         //-----------------------------------------------------------------------------
  596.         // ArrayElementsHaveSpace
  597.         // It checks all input array elements if any of them has space character
  598.         // returns true if found space character in one of the array elements.
  599.         // otherwise returns false.
  600.         //-----------------------------------------------------------------------------
  601.        
  602.         private static bool ArrayElementsHaveSpace(string[] array)
  603.         {
  604.            
  605.             for (int i = 0; i < array.Length; i++) {
  606.                 // it is faster to check for space character manually instead of calling IndexOf
  607.                 // so we don't have to go to native code side.
  608.                 for (int j = 0; j < array[i].Length; j++) {
  609.                     if (Char.IsWhiteSpace(array[i][j])) {
  610.                         return true;
  611.                     }
  612.                 }
  613.             }
  614.            
  615.             return false;
  616.         }
  617.        
  618.        
  619.         ////////////////////////////////////////////////////////////////////////////
  620.         //
  621.         // Check if any element of the array start with a digit.
  622.         //
  623.         ////////////////////////////////////////////////////////////////////////////
  624.         private static bool ArrayElementsBeginWithDigit(string[] array)
  625.         {
  626.            
  627.             for (int i = 0; i < array.Length; i++) {
  628.                 // it is faster to check for space character manually instead of calling IndexOf
  629.                 // so we don't have to go to native code side.
  630.                 if (array[i].Length > 0 && array[i][0] >= '0' && array[i][0] <= '9') {
  631.                     int index = 1;
  632.                     while (index < array[i].Length && array[i][index] >= '0' && array[i][index] <= '9') {
  633.                         // Skip other digits.
  634.                         index++;
  635.                     }
  636.                     if (index == array[i].Length) {
  637.                         return (false);
  638.                     }
  639.                    
  640.                     if (index == array[i].Length - 1) {
  641.                         // Skip known CJK month suffix.
  642.                         // CJK uses month name like "1\x6708", since \x6708 is a known month suffix,
  643.                         // we don't need the UseDigitPrefixInTokens since it is slower.
  644.                         switch (array[i][index]) {
  645.                             case '月':
  646.                             case '월':
  647.                                 // CJKMonthSuff
  648.                                 // KoreanMonthSuff
  649.                                 return (false);
  650.                         }
  651.                     }
  652.                     return (true);
  653.                 }
  654.             }
  655.            
  656.             return false;
  657.         }
  658.        
  659.     }
  660. }

Developer Fusion