The Labs \ Source Viewer \ SSCLI \ System \ ParseFlags

  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. // Class: DateTimeParse
  18. //
  19. // Purpose: This class is called by DateTime to parse a date/time string.
  20. //
  21. ////////////////////////////////////////////////////////////////////////////
  22. namespace System
  23. {
  24.     using System;
  25.     using System.Text;
  26.     using System.Globalization;
  27.     using System.Threading;
  28.     using System.Collections;
  29.    
  30.     ////////////////////////////////////////////////////////////////////////
  31.     //This class contains only static members
  32.    
  33.     static internal class DateTimeParse
  34.     {
  35.        
  36.         internal const Int32 MaxDateTimeNumberDigits = 8;
  37.        
  38.         internal delegate bool MatchNumberDelegate(ref __DTString str, int digitLen, out int result);
  39.        
  40.         static internal MatchNumberDelegate m_hebrewNumberParser = new MatchNumberDelegate(DateTimeParse.MatchHebrewDigits);
  41.        
  42.         static internal DateTime ParseExact(string s, string format, DateTimeFormatInfo dtfi, DateTimeStyles style)
  43.         {
  44.             DateTimeResult result = new DateTimeResult();
  45.             // The buffer to store the parsing result.
  46.             result.Init();
  47.             if (TryParseExact(s, format, dtfi, style, ref result)) {
  48.                 return result.parsedDate;
  49.             }
  50.             else {
  51.                 throw GetDateTimeParseException(ref result);
  52.             }
  53.         }
  54.        
  55.         static internal bool TryParseExact(string s, string format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result)
  56.         {
  57.             result = DateTime.MinValue;
  58.             DateTimeResult resultData = new DateTimeResult();
  59.             // The buffer to store the parsing result.
  60.             resultData.Init();
  61.             if (TryParseExact(s, format, dtfi, style, ref resultData)) {
  62.                 result = resultData.parsedDate;
  63.                 return true;
  64.             }
  65.             return false;
  66.         }
  67.        
  68.         static internal bool TryParseExact(string s, string format, DateTimeFormatInfo dtfi, DateTimeStyles style, ref DateTimeResult result)
  69.         {
  70.             if (s == null) {
  71.                 result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "s");
  72.                 return false;
  73.             }
  74.             if (format == null) {
  75.                 result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "format");
  76.                 return false;
  77.             }
  78.             if (s.Length == 0) {
  79.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  80.                 return false;
  81.             }
  82.            
  83.             if (format.Length == 0) {
  84.                 result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
  85.                 return false;
  86.             }
  87.            
  88.             BCLDebug.Assert(dtfi != null, "dtfi == null");
  89.            
  90.             return DoStrictParse(s, format, style, dtfi, ref result);
  91.         }
  92.        
  93.         static internal DateTime ParseExactMultiple(string s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style)
  94.         {
  95.             DateTimeResult result = new DateTimeResult();
  96.             // The buffer to store the parsing result.
  97.             result.Init();
  98.             if (TryParseExactMultiple(s, formats, dtfi, style, ref result)) {
  99.                 return result.parsedDate;
  100.             }
  101.             else {
  102.                 throw GetDateTimeParseException(ref result);
  103.             }
  104.         }
  105.        
  106.         static internal bool TryParseExactMultiple(string s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result)
  107.         {
  108.             result = DateTime.MinValue;
  109.             DateTimeResult resultData = new DateTimeResult();
  110.             // The buffer to store the parsing result.
  111.             resultData.Init();
  112.             if (TryParseExactMultiple(s, formats, dtfi, style, ref resultData)) {
  113.                 result = resultData.parsedDate;
  114.                 return true;
  115.             }
  116.             return false;
  117.         }
  118.        
  119.         static internal bool TryParseExactMultiple(string s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, ref DateTimeResult result)
  120.         {
  121.             if (s == null) {
  122.                 result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "s");
  123.                 return false;
  124.             }
  125.             if (formats == null) {
  126.                 result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "formats");
  127.                 return false;
  128.             }
  129.            
  130.             if (s.Length == 0) {
  131.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  132.                 return false;
  133.             }
  134.            
  135.             if (formats.Length == 0) {
  136.                 result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
  137.                 return false;
  138.             }
  139.            
  140.             BCLDebug.Assert(dtfi != null, "dtfi == null");
  141.            
  142.             //
  143.             // Do a loop through the provided formats and see if we can parse succesfully in
  144.             // one of the formats.
  145.             //
  146.             for (int i = 0; i < formats.Length; i++) {
  147.                 if (formats[i] == null || formats[i].Length == 0) {
  148.                     result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
  149.                     return false;
  150.                 }
  151.                 if (TryParseExact(s, formats[i], dtfi, style, out result.parsedDate)) {
  152.                     return (true);
  153.                 }
  154.             }
  155.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  156.             return (false);
  157.         }
  158.        
  159.         ////////////////////////////////////////////////////////////////////////////
  160.         // Date Token Types
  161.         //
  162.         // Following is the set of tokens that can be generated from a date
  163.         // string. Notice that the legal set of trailing separators have been
  164.         // folded in with the date number, and month name tokens. This set
  165.         // of tokens is chosen to reduce the number of date parse states.
  166.         //
  167.         ////////////////////////////////////////////////////////////////////////////
  168.        
  169.         internal enum DTT : int
  170.         {
  171.            
  172.             End = 0,
  173.             // '\0'
  174.             NumEnd = 1,
  175.             // Num[ ]*[\0]
  176.             NumAmpm = 2,
  177.             // Num[ ]+AmPm
  178.             NumSpace = 3,
  179.             // Num[ ]+^[Dsep|Tsep|'0\']
  180.             NumDatesep = 4,
  181.             // Num[ ]*Dsep
  182.             NumTimesep = 5,
  183.             // Num[ ]*Tsep
  184.             MonthEnd = 6,
  185.             // Month[ ]*'\0'
  186.             MonthSpace = 7,
  187.             // Month[ ]+^[Dsep|Tsep|'\0']
  188.             MonthDatesep = 8,
  189.             // Month[ ]*Dsep
  190.             NumDatesuff = 9,
  191.             // Month[ ]*DSuff
  192.             NumTimesuff = 10,
  193.             // Month[ ]*TSuff
  194.             DayOfWeek = 11,
  195.             // Day of week name
  196.             YearSpace = 12,
  197.             // Year+^[Dsep|Tsep|'0\']
  198.             YearDateSep = 13,
  199.             // Year+Dsep
  200.             YearEnd = 14,
  201.             // Year+['\0']
  202.             TimeZone = 15,
  203.             // timezone name
  204.             Era = 16,
  205.             // era name
  206.             NumUTCTimeMark = 17,
  207.             // Num + 'Z'
  208.             // When you add a new token which will be in the
  209.             // state table, add it after NumLocalTimeMark.
  210.             Unk = 18,
  211.             // unknown
  212.             NumLocalTimeMark = 19,
  213.             // Num + 'T'
  214.             Max = 20
  215.             // marker
  216.         }
  217.        
  218.         internal enum TM
  219.         {
  220.             NotSet = -1,
  221.             AM = 0,
  222.             PM = 1
  223.         }
  224.        
  225.        
  226.         ////////////////////////////////////////////////////////////////////////////
  227.         //
  228.         // DateTime parsing state enumeration (DS.*)
  229.         //
  230.         ////////////////////////////////////////////////////////////////////////////
  231.        
  232.         internal enum DS
  233.         {
  234.             BEGIN = 0,
  235.             N = 1,
  236.             // have one number
  237.             NN = 2,
  238.             // have two numbers
  239.             // The following are known to be part of a date
  240.            
  241.             D_Nd = 3,
  242.             // date string: have number followed by date separator
  243.             D_NN = 4,
  244.             // date string: have two numbers
  245.             D_NNd = 5,
  246.             // date string: have two numbers followed by date separator
  247.             D_M = 6,
  248.             // date string: have a month
  249.             D_MN = 7,
  250.             // date string: have a month and a number
  251.             D_NM = 8,
  252.             // date string: have a number and a month
  253.             D_MNd = 9,
  254.             // date string: have a month and number followed by date separator
  255.             D_NDS = 10,
  256.             // date string: have one number followed a date suffix.
  257.             D_Y = 11,
  258.             // date string: have a year.
  259.             D_YN = 12,
  260.             // date string: have a year and a number
  261.             D_YNd = 13,
  262.             // date string: have a year and a number and a date separator
  263.             D_YM = 14,
  264.             // date string: have a year and a month
  265.             D_YMd = 15,
  266.             // date string: have a year and a month and a date separator
  267.             D_S = 16,
  268.             // have numbers followed by a date suffix.
  269.             T_S = 17,
  270.             // have numbers followed by a time suffix.
  271.             // The following are known to be part of a time
  272.            
  273.             T_Nt = 18,
  274.             // have num followed by time separator
  275.             T_NNt = 19,
  276.             // have two numbers followed by time separator
  277.            
  278.             ERROR = 20,
  279.            
  280.             // The following are terminal states. These all have an action
  281.             // associated with them; and transition back to BEGIN.
  282.            
  283.             DX_NN = 21,
  284.             // day from two numbers
  285.             DX_NNN = 22,
  286.             // day from three numbers
  287.             DX_MN = 23,
  288.             // day from month and one number
  289.             DX_NM = 24,
  290.             // day from month and one number
  291.             DX_MNN = 25,
  292.             // day from month and two numbers
  293.             DX_DS = 26,
  294.             // a set of date suffixed numbers.
  295.             DX_DSN = 27,
  296.             // day from date suffixes and one number.
  297.             DX_NDS = 28,
  298.             // day from one number and date suffixes .
  299.             DX_NNDS = 29,
  300.             // day from one number and date suffixes .
  301.             DX_YNN = 30,
  302.             // date string: have a year and two number
  303.             DX_YMN = 31,
  304.             // date string: have a year, a month, and a number.
  305.             DX_YN = 32,
  306.             // date string: have a year and one number
  307.             DX_YM = 33,
  308.             // date string: have a year, a month.
  309.             TX_N = 34,
  310.             // time from one number (must have ampm)
  311.             TX_NN = 35,
  312.             // time from two numbers
  313.             TX_NNN = 36,
  314.             // time from three numbers
  315.             TX_TS = 37,
  316.             // a set of time suffixed numbers.
  317.             DX_NNY = 38
  318.         }
  319.        
  320.         ////////////////////////////////////////////////////////////////////////////
  321.         //
  322.         // NOTE: The following state machine table is dependent on the order of the
  323.         // DS and DTT enumerations.
  324.         //
  325.         // For each non terminal state, the following table defines the next state
  326.         // for each given date token type.
  327.         //
  328.         ////////////////////////////////////////////////////////////////////////////
  329.        
  330.         // End NumEnd NumAmPm NumSpace NumDaySep NumTimesep MonthEnd MonthSpace MonthDSep NumDateSuff NumTimeSuff DayOfWeek YearSpace YearDateSep YearEnd TimeZone Era UTCTimeMark
  331.         private static DS[][] dateParsingStates = {new DS[] {DS.BEGIN, DS.ERROR, DS.TX_N, DS.N, DS.D_Nd, DS.T_Nt, DS.ERROR, DS.D_M, DS.D_M, DS.D_S,
  332.         DS.T_S, DS.BEGIN, DS.D_Y, DS.D_Y, DS.ERROR, DS.BEGIN, DS.BEGIN, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_NN, DS.ERROR, DS.NN, DS.D_NNd, DS.ERROR, DS.DX_NM, DS.D_NM, DS.D_MNd, DS.D_NDS,
  333.         DS.ERROR, DS.N, DS.D_YN, DS.D_YNd, DS.DX_YN, DS.N, DS.N, DS.ERROR}, new DS[] {DS.DX_NN, DS.DX_NNN, DS.TX_N, DS.DX_NNN, DS.ERROR, DS.T_Nt, DS.DX_MNN, DS.DX_MNN, DS.ERROR, DS.ERROR,
  334.         DS.T_S, DS.NN, DS.DX_NNY, DS.ERROR, DS.DX_NNY, DS.NN, DS.NN, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_NN, DS.ERROR, DS.D_NN, DS.D_NNd, DS.ERROR, DS.DX_NM, DS.D_MN, DS.D_MNd, DS.ERROR,
  335.         DS.ERROR, DS.D_Nd, DS.D_YN, DS.D_YNd, DS.DX_YN, DS.ERROR, DS.D_Nd, DS.ERROR}, new DS[] {DS.DX_NN, DS.DX_NNN, DS.TX_N, DS.DX_NNN, DS.ERROR, DS.T_Nt, DS.DX_MNN, DS.DX_MNN, DS.ERROR, DS.DX_DS,
  336.         DS.T_S, DS.D_NN, DS.DX_NNY, DS.ERROR, DS.DX_NNY, DS.ERROR, DS.D_NN, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_NNN, DS.DX_NNN, DS.DX_NNN, DS.ERROR, DS.ERROR, DS.DX_MNN, DS.DX_MNN, DS.ERROR, DS.DX_DS,
  337.         DS.ERROR, DS.D_NNd, DS.DX_NNY, DS.ERROR, DS.DX_NNY, DS.ERROR, DS.D_NNd, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_MN, DS.ERROR, DS.D_MN, DS.D_MNd, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR,
  338.         DS.ERROR, DS.D_M, DS.D_YM, DS.D_YMd, DS.DX_YM, DS.ERROR, DS.D_M, DS.ERROR}, new DS[] {DS.DX_MN, DS.DX_MNN, DS.DX_MNN, DS.DX_MNN, DS.ERROR, DS.T_Nt, DS.ERROR, DS.ERROR, DS.ERROR, DS.DX_DS,
  339.         DS.T_S, DS.D_MN, DS.DX_YMN, DS.ERROR, DS.DX_YMN, DS.ERROR, DS.D_MN, DS.ERROR}, new DS[] {DS.DX_NM, DS.DX_MNN, DS.DX_MNN, DS.DX_MNN, DS.ERROR, DS.T_Nt, DS.ERROR, DS.ERROR, DS.ERROR, DS.DX_DS,
  340.         DS.T_S, DS.D_NM, DS.DX_YMN, DS.ERROR, DS.DX_YMN, DS.ERROR, DS.D_NM, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_MNN, DS.ERROR, DS.DX_MNN, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR,
  341.         DS.ERROR, DS.D_MNd, DS.DX_YMN, DS.ERROR, DS.DX_YMN, DS.ERROR, DS.D_MNd, DS.ERROR},
  342.         new DS[] {DS.DX_NDS, DS.DX_NNDS, DS.DX_NNDS, DS.DX_NNDS, DS.ERROR, DS.T_Nt, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_NDS,
  343.         DS.T_S, DS.D_NDS, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_NDS, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_YN, DS.ERROR, DS.D_YN, DS.D_YNd, DS.ERROR, DS.DX_YM, DS.D_YM, DS.D_YMd, DS.D_YM,
  344.         DS.ERROR, DS.D_Y, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_Y, DS.ERROR}, new DS[] {DS.DX_YN, DS.DX_YNN, DS.DX_YNN, DS.DX_YNN, DS.ERROR, DS.ERROR, DS.DX_YMN, DS.DX_YMN, DS.ERROR, DS.ERROR,
  345.         DS.ERROR, DS.D_YN, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_YN, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_YNN, DS.DX_YNN, DS.DX_YNN, DS.ERROR, DS.ERROR, DS.DX_YMN, DS.DX_YMN, DS.ERROR, DS.ERROR,
  346.         DS.ERROR, DS.D_YN, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_YN, DS.ERROR}, new DS[] {DS.DX_YM, DS.DX_YMN, DS.DX_YMN, DS.DX_YMN, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR,
  347.         DS.ERROR, DS.D_YM, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_YM, DS.ERROR}, new DS[] {DS.ERROR, DS.DX_YMN, DS.DX_YMN, DS.DX_YMN, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR,
  348.         DS.ERROR, DS.D_YM, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_YM, DS.ERROR}, new DS[] {DS.DX_DS, DS.DX_DSN, DS.TX_N, DS.T_Nt, DS.ERROR, DS.T_Nt, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_S,
  349.         DS.T_S, DS.D_S, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_S, DS.ERROR}, new DS[] {DS.TX_TS, DS.TX_TS, DS.TX_TS, DS.T_Nt, DS.D_Nd, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.D_S,
  350.         DS.T_S, DS.T_S, DS.ERROR, DS.ERROR, DS.ERROR, DS.T_S, DS.T_S, DS.ERROR}, new DS[] {DS.ERROR, DS.TX_NN, DS.TX_NN, DS.TX_NN, DS.ERROR, DS.T_NNt, DS.DX_NM, DS.D_NM, DS.ERROR, DS.ERROR,
  351.         DS.T_S, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.T_Nt, DS.T_Nt, DS.TX_NN}, new DS[] {DS.ERROR, DS.TX_NNN, DS.TX_NNN, DS.TX_NNN, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR, DS.ERROR,
  352.         DS.T_S, DS.T_NNt, DS.ERROR, DS.ERROR, DS.ERROR, DS.T_NNt, DS.T_NNt, DS.TX_NNN}
  353.             // DS.BEGIN // DS.BEGIN
  354.            
  355.             // DS.N // DS.N
  356.            
  357.             // DS.NN // DS.NN
  358.            
  359.             // DS.D_Nd // DS.D_Nd
  360.            
  361.             // DS.D_NN // DS.D_NN
  362.            
  363.             // DS.D_NNd // DS.D_NNd
  364.            
  365.             // DS.D_M // DS.D_M
  366.            
  367.             // DS.D_MN // DS.D_MN
  368.            
  369.             // DS.D_NM // DS.D_NM
  370.            
  371.             // DS.D_MNd // DS.D_MNd
  372.            
  373.             // DS.D_NDS, // DS.D_NDS,
  374.            
  375.             // DS.D_Y // DS.D_Y
  376.            
  377.             // DS.D_YN // DS.D_YN
  378.            
  379.             // DS.D_YNd // DS.D_YNd
  380.            
  381.             // DS.D_YM // DS.D_YM
  382.            
  383.             // DS.D_YMd // DS.D_YMd
  384.            
  385.             // DS.D_S // DS.D_S
  386.            
  387.             // DS.T_S // DS.T_S
  388.            
  389.             // DS.T_Nt // DS.T_Nt
  390.            
  391.             // DS.T_NNt // DS.T_NNt
  392.            
  393.         };
  394.         // End NumEnd NumAmPm NumSpace NumDaySep NumTimesep MonthEnd MonthSpace MonthDSep NumDateSuff NumTimeSuff DayOfWeek YearSpace YearDateSep YearEnd TimeZone Era UTCMark
  395.        
  396.         internal const string GMTName = "GMT";
  397.         internal const string ZuluName = "Z";
  398.        
  399.         //
  400.         // Search from the index of str at str.Index to see if the target string exists in the str.
  401.         //
  402.         private static bool MatchWord(ref __DTString str, string target)
  403.         {
  404.             int length = target.Length;
  405.             if (length > (str.Value.Length - str.Index)) {
  406.                 return false;
  407.             }
  408.            
  409.             if (str.CompareInfo.Compare(str.Value, str.Index, length, target, 0, length, CompareOptions.IgnoreCase) != 0) {
  410.                 return (false);
  411.             }
  412.            
  413.             int nextCharIndex = str.Index + target.Length;
  414.            
  415.             if (nextCharIndex < str.Value.Length) {
  416.                 char nextCh = str.Value[nextCharIndex];
  417.                 if (Char.IsLetter(nextCh)) {
  418.                     return (false);
  419.                 }
  420.             }
  421.             str.Index = nextCharIndex;
  422.             if (str.Index < str.len) {
  423.                 str.m_current = str.Value[str.Index];
  424.             }
  425.            
  426.             return (true);
  427.         }
  428.        
  429.        
  430.         //
  431.         // Check the word at the current index to see if it matches GMT name or Zulu name.
  432.         //
  433.         private static bool GetTimeZoneName(ref __DTString str)
  434.         {
  435.             //
  436.             //
  437.             if (MatchWord(ref str, GMTName)) {
  438.                 return (true);
  439.             }
  440.            
  441.             if (MatchWord(ref str, ZuluName)) {
  442.                 return (true);
  443.             }
  444.            
  445.             return (false);
  446.         }
  447.        
  448.         static internal bool IsDigit(char ch)
  449.         {
  450.             return (ch >= '0' && ch <= '9');
  451.         }
  452.        
  453.        
  454. /*=================================ParseFraction==========================
  455.         **Action: Starting at the str.Index, which should be a decimal symbol.
  456.         ** if the current character is a digit, parse the remaining
  457.         **      numbers as fraction.  For example, if the sub-string starting at str.Index is "123", then
  458.         **      the method will return 0.123
  459.         **Returns:      The fraction number.
  460.         **Arguments:
  461.         **      str the parsing string
  462.         **Exceptions:
  463.         ============================================================================*/       
  464.        
  465.         private static bool ParseFraction(ref __DTString str, out double result)
  466.         {
  467.             result = 0;
  468.             double decimalBase = 0.1;
  469.             int digits = 0;
  470.             char ch;
  471.             while (str.GetNext() && IsDigit(ch = str.m_current)) {
  472.                 result += (ch - '0') * decimalBase;
  473.                 decimalBase *= 0.1;
  474.                 digits++;
  475.             }
  476.             return (digits > 0);
  477.         }
  478.        
  479. /*=================================ParseTimeZone==========================
  480.         **Action: Parse the timezone offset in the following format:
  481.         **          "+8", "+08", "+0800", "+0800"
  482.         **        This method is used by DateTime.Parse().
  483.         **Returns:      The TimeZone offset.
  484.         **Arguments:
  485.         **      str the parsing string
  486.         **Exceptions:
  487.         **      FormatException if invalid timezone format is found.
  488.         ============================================================================*/       
  489.        
  490.         private static bool ParseTimeZone(ref __DTString str, ref TimeSpan result)
  491.         {
  492.             // The hour/minute offset for timezone.
  493.             int hourOffset = 0;
  494.             int minuteOffset = 0;
  495.             DTSubString sub;
  496.            
  497.             // Consume the +/- character that has already been read
  498.             sub = str.GetSubString();
  499.             if (sub.length != 1) {
  500.                 return false;
  501.             }
  502.             char offsetChar = sub[0];
  503.             if (offsetChar != '+' && offsetChar != '-') {
  504.                 return false;
  505.             }
  506.             str.ConsumeSubString(sub);
  507.            
  508.             sub = str.GetSubString();
  509.             if (sub.type != DTSubStringType.Number) {
  510.                 return false;
  511.             }
  512.             int value = sub.value;
  513.             int length = sub.length;
  514.             if (length == 1 || length == 2) {
  515.                 // Parsing "+8" or "+08"
  516.                 hourOffset = value;
  517.                 str.ConsumeSubString(sub);
  518.                 sub = str.GetSubString();
  519.                 if (sub.length == 1 && sub[0] == ':') {
  520.                     // Parsing "+8:00" or "+08:00"
  521.                     str.ConsumeSubString(sub);
  522.                     sub = str.GetSubString();
  523.                     if (sub.type != DTSubStringType.Number || sub.length < 1 || sub.length > 2) {
  524.                         return false;
  525.                     }
  526.                     minuteOffset = sub.value;
  527.                     str.ConsumeSubString(sub);
  528.                 }
  529.             }
  530.             else if (length == 3 || length == 4) {
  531.                 // Parsing "+800" or "+0800"
  532.                 hourOffset = value / 100;
  533.                 minuteOffset = value % 100;
  534.                 str.ConsumeSubString(sub);
  535.             }
  536.             else {
  537.                 return false;
  538.             }
  539.             BCLDebug.Assert(hourOffset >= 0 && hourOffset <= 99, "hourOffset >= 0 && hourOffset <= 99");
  540.             BCLDebug.Assert(minuteOffset >= 0 && minuteOffset <= 99, "minuteOffset >= 0 && minuteOffset <= 99");
  541.             if (minuteOffset < 0 || minuteOffset >= 60) {
  542.                 return false;
  543.             }
  544.             result = new TimeSpan(hourOffset, minuteOffset, 0);
  545.             if (offsetChar == '-') {
  546.                 result = result.Negate();
  547.             }
  548.             return true;
  549.         }
  550.        
  551.         //
  552.         // This is the lexer. Check the character at the current index, and put the found token in dtok and
  553.         // some raw date/time information in raw.
  554.         //
  555.         private static bool Lex(DS dps, ref __DTString str, ref DateTimeToken dtok, ref DateTimeRawInfo raw, ref DateTimeResult result, ref DateTimeFormatInfo dtfi)
  556.         {
  557.            
  558.             TokenType tokenType;
  559.             int tokenValue;
  560.            
  561.             TokenType sep;
  562.             dtok.dtt = DTT.Unk;
  563.             // Assume the token is unkown.
  564.             str.GetRegularToken(out tokenType, out tokenValue, dtfi);
  565.            
  566.             // Look at the regular token.
  567.             switch (tokenType) {
  568.                 case TokenType.NumberToken:
  569.                 case TokenType.YearNumberToken:
  570.                     if (raw.numCount == 3 || tokenValue == -1) {
  571.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  572.                         return false;
  573.                     }
  574.                     //
  575.                     // This is a digit.
  576.                     //
  577.                     // If the previous parsing state is DS.T_NNt (like 12:01), and we got another number,
  578.                     // so we will have a terminal state DS.TX_NNN (like 12:01:02).
  579.                     // If the previous parsing state is DS.T_Nt (like 12:), and we got another number,
  580.                     // so we will have a terminal state DS.TX_NN (like 12:01).
  581.                     //
  582.                     // Look ahead to see if the following character is a decimal point or timezone offset.
  583.                     // This enables us to parse time in the forms of:
  584.                     // "11:22:33.1234" or "11:22:33-08".
  585.                     if (dps == DS.T_NNt) {
  586.                         if ((str.Index < str.len - 1)) {
  587.                             char nextCh = str.Value[str.Index];
  588.                             if (nextCh == '.') {
  589.                                 // While ParseFraction can fail, it just means that there were no digits after
  590.                                 // the dot. In this case ParseFraction just swallows the dot. This is actually
  591.                                 // valid for cultures like Albanian, that join the time marker to the time with
  592.                                 // with a dot: e.g. "9:03.MD"
  593.                                 ParseFraction(ref str, out raw.fraction);
  594.                             }
  595.                         }
  596.                     }
  597.                     if (dps == DS.T_NNt || dps == DS.T_Nt) {
  598.                         if ((str.Index < str.len - 1)) {
  599.                             char nextCh = str.Value[str.Index];
  600.                             // Skip whitespace, but don't update the index unless we find a time zone marker
  601.                             int whitespaceCount = 0;
  602.                             while (Char.IsWhiteSpace(nextCh) && str.Index + whitespaceCount < str.len - 1) {
  603.                                 whitespaceCount++;
  604.                                 nextCh = str.Value[str.Index + whitespaceCount];
  605.                             }
  606.                             if (nextCh == '+' || nextCh == '-') {
  607.                                 str.Index += whitespaceCount;
  608.                                 if ((result.flags & ParseFlags.TimeZoneUsed) != 0) {
  609.                                     // Should not have two timezone offsets.
  610.                                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  611.                                     return false;
  612.                                 }
  613.                                 result.flags |= ParseFlags.TimeZoneUsed;
  614.                                 if (!ParseTimeZone(ref str, ref result.timeZoneOffset)) {
  615.                                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  616.                                     return false;
  617.                                 }
  618.                             }
  619.                         }
  620.                     }
  621.                    
  622.                     dtok.num = tokenValue;
  623.                     if (tokenType == TokenType.YearNumberToken) {
  624.                         if (raw.year == -1) {
  625.                             raw.year = tokenValue;
  626.                             //
  627.                             // If we have number which has 3 or more digits (like "001" or "0001"),
  628.                             // we assume this number is a year. Save the currnet raw.numCount in
  629.                             // raw.year.
  630.                             //
  631.                             switch (sep = str.GetSeparatorToken(dtfi)) {
  632.                                 case TokenType.SEP_End:
  633.                                     dtok.dtt = DTT.YearEnd;
  634.                                     break;
  635.                                 case TokenType.SEP_Am:
  636.                                 case TokenType.SEP_Pm:
  637.                                     if (raw.timeMark == TM.NotSet) {
  638.                                         raw.timeMark = (sep == TokenType.SEP_Am ? TM.AM : TM.PM);
  639.                                         dtok.dtt = DTT.YearSpace;
  640.                                     }
  641.                                     else {
  642.                                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  643.                                     }
  644.                                     break;
  645.                                 case TokenType.SEP_Space:
  646.                                     dtok.dtt = DTT.YearSpace;
  647.                                     break;
  648.                                 case TokenType.SEP_Date:
  649.                                     dtok.dtt = DTT.YearDateSep;
  650.                                     break;
  651.                                 case TokenType.SEP_YearSuff:
  652.                                 case TokenType.SEP_MonthSuff:
  653.                                 case TokenType.SEP_DaySuff:
  654.                                     dtok.dtt = DTT.NumDatesuff;
  655.                                     dtok.suffix = sep;
  656.                                     break;
  657.                                 case TokenType.SEP_HourSuff:
  658.                                 case TokenType.SEP_MinuteSuff:
  659.                                 case TokenType.SEP_SecondSuff:
  660.                                     dtok.dtt = DTT.NumTimesuff;
  661.                                     dtok.suffix = sep;
  662.                                     break;
  663.                                 default:
  664.                                     // Invalid separator after number number.
  665.                                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  666.                                     return false;
  667.                             }
  668.                             //
  669.                             // Found the token already. Return now.
  670.                             //
  671.                             return true;
  672.                         }
  673.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  674.                         return false;
  675.                     }
  676.                     switch (sep = str.GetSeparatorToken(dtfi)) {
  677.                         case TokenType.SEP_End:
  678.                             //
  679.                             // Note here we check if the numCount is less than three.
  680.                             // When we have more than three numbers, it will be caught as error in the state machine.
  681.                             //
  682.                             dtok.dtt = DTT.NumEnd;
  683.                             raw.AddNumber(dtok.num);
  684.                             break;
  685.                         case TokenType.SEP_Am:
  686.                         case TokenType.SEP_Pm:
  687.                             if (raw.timeMark == TM.NotSet) {
  688.                                 raw.timeMark = (sep == TokenType.SEP_Am ? TM.AM : TM.PM);
  689.                                 dtok.dtt = DTT.NumAmpm;
  690.                                 raw.AddNumber(dtok.num);
  691.                             }
  692.                             else {
  693.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  694.                             }
  695.                             break;
  696.                         case TokenType.SEP_Space:
  697.                             dtok.dtt = DTT.NumSpace;
  698.                             raw.AddNumber(dtok.num);
  699.                             break;
  700.                         case TokenType.SEP_Date:
  701.                             dtok.dtt = DTT.NumDatesep;
  702.                             raw.AddNumber(dtok.num);
  703.                             break;
  704.                         case TokenType.SEP_Time:
  705.                             if ((result.flags & ParseFlags.TimeZoneUsed) == 0) {
  706.                                 dtok.dtt = DTT.NumTimesep;
  707.                                 raw.AddNumber(dtok.num);
  708.                             }
  709.                             else {
  710.                                 // If we already got timezone, there should be no
  711.                                 // time separator again.
  712.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  713.                                 return false;
  714.                             }
  715.                             break;
  716.                         case TokenType.SEP_YearSuff:
  717.                             dtok.num = dtfi.Calendar.ToFourDigitYear(tokenValue);
  718.                             dtok.dtt = DTT.NumDatesuff;
  719.                             dtok.suffix = sep;
  720.                             break;
  721.                         case TokenType.SEP_MonthSuff:
  722.                         case TokenType.SEP_DaySuff:
  723.                             dtok.dtt = DTT.NumDatesuff;
  724.                             dtok.suffix = sep;
  725.                             break;
  726.                         case TokenType.SEP_HourSuff:
  727.                         case TokenType.SEP_MinuteSuff:
  728.                         case TokenType.SEP_SecondSuff:
  729.                             dtok.dtt = DTT.NumTimesuff;
  730.                             dtok.suffix = sep;
  731.                             break;
  732.                         case TokenType.SEP_LocalTimeMark:
  733.                             dtok.dtt = DTT.NumLocalTimeMark;
  734.                             raw.AddNumber(dtok.num);
  735.                             break;
  736.                         default:
  737.                             // Invalid separator after number number.
  738.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  739.                             return false;
  740.                     }
  741.                     break;
  742.                 case TokenType.HebrewNumber:
  743.                     if (tokenValue >= 100) {
  744.                         // This is a year number
  745.                         if (raw.year == -1) {
  746.                             raw.year = tokenValue;
  747.                             //
  748.                             // If we have number which has 3 or more digits (like "001" or "0001"),
  749.                             // we assume this number is a year. Save the currnet raw.numCount in
  750.                             // raw.year.
  751.                             //
  752.                             switch (sep = str.GetSeparatorToken(dtfi)) {
  753.                                 case TokenType.SEP_End:
  754.                                     dtok.dtt = DTT.YearEnd;
  755.                                     break;
  756.                                 case TokenType.SEP_Space:
  757.                                     dtok.dtt = DTT.YearSpace;
  758.                                     break;
  759.                                 default:
  760.                                     // Invalid separator after number number.
  761.                                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  762.                                     return false;
  763.                             }
  764.                         }
  765.                         else {
  766.                             // Invalid separator after number number.
  767.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  768.                             return false;
  769.                         }
  770.                     }
  771.                     else {
  772.                         // This is a day number
  773.                         dtok.num = tokenValue;
  774.                         raw.AddNumber(dtok.num);
  775.                        
  776.                         switch (sep = str.GetSeparatorToken(dtfi)) {
  777.                             case TokenType.SEP_End:
  778.                                 //
  779.                                 // Note here we check if the numCount is less than three.
  780.                                 // When we have more than three numbers, it will be caught as error in the state machine.
  781.                                 //
  782.                                 dtok.dtt = DTT.NumEnd;
  783.                                 break;
  784.                             case TokenType.SEP_Space:
  785.                             case TokenType.SEP_Date:
  786.                                 dtok.dtt = DTT.NumDatesep;
  787.                                 break;
  788.                             default:
  789.                                 // Invalid separator after number number.
  790.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  791.                                 return false;
  792.                         }
  793.                     }
  794.                     break;
  795.                 case TokenType.DayOfWeekToken:
  796.                     if (raw.dayOfWeek == -1) {
  797.                         //
  798.                         // This is a day of week name.
  799.                         //
  800.                         raw.dayOfWeek = tokenValue;
  801.                         dtok.dtt = DTT.DayOfWeek;
  802.                     }
  803.                     else {
  804.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  805.                         return false;
  806.                     }
  807.                     break;
  808.                 case TokenType.MonthToken:
  809.                     if (raw.month == -1) {
  810.                         //
  811.                         // This is a month name
  812.                         //
  813.                         switch (sep = str.GetSeparatorToken(dtfi)) {
  814.                             case TokenType.SEP_End:
  815.                                 dtok.dtt = DTT.MonthEnd;
  816.                                 break;
  817.                             case TokenType.SEP_Space:
  818.                                 dtok.dtt = DTT.MonthSpace;
  819.                                 break;
  820.                             case TokenType.SEP_Date:
  821.                                 dtok.dtt = DTT.MonthDatesep;
  822.                                 break;
  823.                             default:
  824.                                 //Invalid separator after month name
  825.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  826.                                 return false;
  827.                         }
  828.                         raw.month = tokenValue;
  829.                     }
  830.                     else {
  831.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  832.                         return false;
  833.                     }
  834.                     break;
  835.                 case TokenType.EraToken:
  836.                     if (result.era != -1) {
  837.                         result.era = tokenValue;
  838.                         dtok.dtt = DTT.Era;
  839.                     }
  840.                     else {
  841.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  842.                         return false;
  843.                     }
  844.                     break;
  845.                 case TokenType.JapaneseEraToken:
  846.                     // Special case for Japanese. We allow Japanese era name to be used even if the calendar is not Japanese Calendar.
  847.                     result.calendar = JapaneseCalendar.GetDefaultInstance();
  848.                     dtfi = DateTimeFormatInfo.GetJapaneseCalendarDTFI();
  849.                     if (result.era != -1) {
  850.                         result.era = tokenValue;
  851.                         dtok.dtt = DTT.Era;
  852.                     }
  853.                     else {
  854.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  855.                         return false;
  856.                     }
  857.                     break;
  858.                 case TokenType.TEraToken:
  859.                     // Special case for Taiwan.
  860.                     result.calendar = TaiwanCalendar.GetDefaultInstance();
  861.                     dtfi = DateTimeFormatInfo.GetTaiwanCalendarDTFI();
  862.                     if (result.era != -1) {
  863.                         result.era = tokenValue;
  864.                         dtok.dtt = DTT.Era;
  865.                     }
  866.                     else {
  867.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  868.                         return false;
  869.                     }
  870.                     break;
  871.                 case TokenType.TimeZoneToken:
  872.                     //
  873.                     dtok.dtt = DTT.TimeZone;
  874.                     result.flags |= ParseFlags.TimeZoneUsed;
  875.                     result.timeZoneOffset = new TimeSpan(0);
  876.                     result.flags |= ParseFlags.TimeZoneUtc;
  877.                     break;
  878.                 case TokenType.EndOfString:
  879.                     dtok.dtt = DTT.End;
  880.                     break;
  881.                 case TokenType.DateWordToken:
  882.                 case TokenType.IgnorableSymbol:
  883.                     // Date words and ignorable symbols can just be skipped over
  884.                     break;
  885.                 case TokenType.Am:
  886.                 case TokenType.Pm:
  887.                     if (raw.timeMark == TM.NotSet) {
  888.                         raw.timeMark = (TM)tokenValue;
  889.                     }
  890.                     else {
  891.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  892.                         return false;
  893.                     }
  894.                     break;
  895.                 case TokenType.UnknownToken:
  896.                     if (Char.IsLetter(str.m_current)) {
  897.                         result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_UnknowDateTimeWord", str.Index);
  898.                         return (false);
  899.                     }
  900.                     else {
  901.                         // If DateTimeParseIgnorePunctuation is defined, we want to have the V1.1 behavior of just
  902.                         // ignoring any unrecognized punctuation and moving on to the next character
  903.                         if (Environment.GetCompatibilityFlag(CompatibilityFlag.DateTimeParseIgnorePunctuation)) {
  904.                             str.GetNext();
  905.                             return true;
  906.                         }
  907.                         else {
  908.                             if (VerifyValidPunctuation(ref str)) {
  909.                                 return true;
  910.                             }
  911.                         }
  912.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  913.                         return false;
  914.                     }
  915.                     break;
  916.             }
  917.            
  918.             return true;
  919.         }
  920.        
  921.         private static bool VerifyValidPunctuation(ref __DTString str)
  922.         {
  923.             // Compatability Behavior. Allow trailing nulls and surrounding hashes
  924.             char ch = str.Value[str.Index];
  925.             if (ch == '#') {
  926.                 bool foundStart = false;
  927.                 bool foundEnd = false;
  928.                 for (int i = 0; i < str.len; i++) {
  929.                     ch = str.Value[i];
  930.                     if (ch == '#') {
  931.                         if (foundStart) {
  932.                             if (foundEnd) {
  933.                                 // Having more than two hashes is invalid
  934.                                 return false;
  935.                             }
  936.                             else {
  937.                                 foundEnd = true;
  938.                             }
  939.                         }
  940.                         else {
  941.                             foundStart = true;
  942.                         }
  943.                     }
  944.                     else if (ch == '\0') {
  945.                         // Allow nulls only at the end
  946.                         if (!foundEnd) {
  947.                             return false;
  948.                         }
  949.                     }
  950.                     else if ((!Char.IsWhiteSpace(ch))) {
  951.                         // Anthyhing other than whitespace outside hashes is invalid
  952.                         if (!foundStart || foundEnd) {
  953.                             return false;
  954.                         }
  955.                     }
  956.                 }
  957.                 if (!foundEnd) {
  958.                     // The has was un-paired
  959.                     return false;
  960.                 }
  961.                 // Valid Hash usage: eat the hash and continue.
  962.                 str.GetNext();
  963.                 return true;
  964.             }
  965.             else if (ch == '\0') {
  966.                 for (int i = str.Index; i < str.len; i++) {
  967.                     if (str.Value[i] != '\0') {
  968.                         // Nulls are only valid if they are the only trailing character
  969.                         return false;
  970.                     }
  971.                 }
  972.                 // Move to the end of the string
  973.                 str.Index = str.len;
  974.                 return true;
  975.             }
  976.             return false;
  977.         }
  978.        
  979.         private const int ORDER_YMD = 0;
  980.         // The order of date is Year/Month/Day.
  981.         private const int ORDER_MDY = 1;
  982.         // The order of date is Month/Day/Year.
  983.         private const int ORDER_DMY = 2;
  984.         // The order of date is Day/Month/Year.
  985.         private const int ORDER_YDM = 3;
  986.         // The order of date is Year/Day/Month
  987.         private const int ORDER_YM = 4;
  988.         // Year/Month order.
  989.         private const int ORDER_MY = 5;
  990.         // Month/Year order.
  991.         private const int ORDER_MD = 6;
  992.         // Month/Day order.
  993.         private const int ORDER_DM = 7;
  994.         // Day/Month order.
  995.         //
  996.         // Decide the year/month/day order from the datePattern.
  997.         //
  998.         // Return 0 for YMD, 1 for MDY, 2 for DMY, otherwise -1.
  999.         //
  1000.         private static bool GetYearMonthDayOrder(string datePattern, DateTimeFormatInfo dtfi, out int order)
  1001.         {
  1002.             int yearOrder = -1;
  1003.             int monthOrder = -1;
  1004.             int dayOrder = -1;
  1005.             int orderCount = 0;
  1006.            
  1007.             bool inQuote = false;
  1008.            
  1009.             for (int i = 0; i < datePattern.Length && orderCount < 3; i++) {
  1010.                 char ch = datePattern[i];
  1011.                 if (ch == '\'' || ch == '"') {
  1012.                     inQuote = !inQuote;
  1013.                 }
  1014.                
  1015.                 if (!inQuote) {
  1016.                     if (ch == 'y') {
  1017.                         yearOrder = orderCount++;
  1018.                        
  1019.                         //
  1020.                         // Skip all year pattern charaters.
  1021.                         //
  1022.                         for (; i + 1 < datePattern.Length && datePattern[i + 1] == 'y'; i++) {
  1023.                             // Do nothing here.
  1024.                         }
  1025.                     }
  1026.                     else if (ch == 'M') {
  1027.                         monthOrder = orderCount++;
  1028.                         //
  1029.                         // Skip all month pattern characters.
  1030.                         //
  1031.                         for (; i + 1 < datePattern.Length && datePattern[i + 1] == 'M'; i++) {
  1032.                             // Do nothing here.
  1033.                         }
  1034.                     }
  1035.                     else if (ch == 'd') {
  1036.                        
  1037.                         int patternCount = 1;
  1038.                         //
  1039.                         // Skip all day pattern characters.
  1040.                         //
  1041.                         for (; i + 1 < datePattern.Length && datePattern[i + 1] == 'd'; i++) {
  1042.                             patternCount++;
  1043.                         }
  1044.                         //
  1045.                         // Make sure this is not "ddd" or "dddd", which means day of week.
  1046.                         //
  1047.                         if (patternCount <= 2) {
  1048.                             dayOrder = orderCount++;
  1049.                         }
  1050.                     }
  1051.                 }
  1052.             }
  1053.            
  1054.             if (yearOrder == 0 && monthOrder == 1 && dayOrder == 2) {
  1055.                 order = ORDER_YMD;
  1056.                 return true;
  1057.             }
  1058.             if (monthOrder == 0 && dayOrder == 1 && yearOrder == 2) {
  1059.                 order = ORDER_MDY;
  1060.                 return true;
  1061.             }
  1062.             if (dayOrder == 0 && monthOrder == 1 && yearOrder == 2) {
  1063.                 order = ORDER_DMY;
  1064.                 return true;
  1065.             }
  1066.             if (yearOrder == 0 && dayOrder == 1 && monthOrder == 2) {
  1067.                 order = ORDER_YDM;
  1068.                 return true;
  1069.             }
  1070.             order = -1;
  1071.             return false;
  1072.         }
  1073.        
  1074.         //
  1075.         // Decide the year/month order from the pattern.
  1076.         //
  1077.         // Return 0 for YM, 1 for MY, otherwise -1.
  1078.         //
  1079.         private static bool GetYearMonthOrder(string pattern, DateTimeFormatInfo dtfi, out int order)
  1080.         {
  1081.             int yearOrder = -1;
  1082.             int monthOrder = -1;
  1083.             int orderCount = 0;
  1084.            
  1085.             bool inQuote = false;
  1086.             for (int i = 0; i < pattern.Length && orderCount < 2; i++) {
  1087.                 char ch = pattern[i];
  1088.                 if (ch == '\'' || ch == '"') {
  1089.                     inQuote = !inQuote;
  1090.                 }
  1091.                
  1092.                 if (!inQuote) {
  1093.                     if (ch == 'y') {
  1094.                         yearOrder = orderCount++;
  1095.                        
  1096.                         //
  1097.                         // Skip all year pattern charaters.
  1098.                         //
  1099.                         for (; i + 1 < pattern.Length && pattern[i + 1] == 'y'; i++) {
  1100.                         }
  1101.                     }
  1102.                     else if (ch == 'M') {
  1103.                         monthOrder = orderCount++;
  1104.                         //
  1105.                         // Skip all month pattern characters.
  1106.                         //
  1107.                         for (; i + 1 < pattern.Length && pattern[i + 1] == 'M'; i++) {
  1108.                         }
  1109.                     }
  1110.                 }
  1111.             }
  1112.            
  1113.             if (yearOrder == 0 && monthOrder == 1) {
  1114.                 order = ORDER_YM;
  1115.                 return true;
  1116.             }
  1117.             if (monthOrder == 0 && yearOrder == 1) {
  1118.                 order = ORDER_MY;
  1119.                 return true;
  1120.             }
  1121.             order = -1;
  1122.             return false;
  1123.         }
  1124.        
  1125.         //
  1126.         // Decide the month/day order from the pattern.
  1127.         //
  1128.         // Return 0 for MD, 1 for DM, otherwise -1.
  1129.         //
  1130.         private static bool GetMonthDayOrder(string pattern, DateTimeFormatInfo dtfi, out int order)
  1131.         {
  1132.             int monthOrder = -1;
  1133.             int dayOrder = -1;
  1134.             int orderCount = 0;
  1135.            
  1136.             bool inQuote = false;
  1137.             for (int i = 0; i < pattern.Length && orderCount < 2; i++) {
  1138.                 char ch = pattern[i];
  1139.                 if (ch == '\'' || ch == '"') {
  1140.                     inQuote = !inQuote;
  1141.                 }
  1142.                
  1143.                 if (!inQuote) {
  1144.                     if (ch == 'd') {
  1145.                         int patternCount = 1;
  1146.                         //
  1147.                         // Skip all day pattern charaters.
  1148.                         //
  1149.                         for (; i + 1 < pattern.Length && pattern[i + 1] == 'd'; i++) {
  1150.                             patternCount++;
  1151.                         }
  1152.                        
  1153.                         //
  1154.                         // Make sure this is not "ddd" or "dddd", which means day of week.
  1155.                         //
  1156.                         if (patternCount <= 2) {
  1157.                             dayOrder = orderCount++;
  1158.                         }
  1159.                        
  1160.                     }
  1161.                     else if (ch == 'M') {
  1162.                         monthOrder = orderCount++;
  1163.                         //
  1164.                         // Skip all month pattern characters.
  1165.                         //
  1166.                         for (; i + 1 < pattern.Length && pattern[i + 1] == 'M'; i++) {
  1167.                         }
  1168.                     }
  1169.                 }
  1170.             }
  1171.            
  1172.             if (monthOrder == 0 && dayOrder == 1) {
  1173.                 order = ORDER_MD;
  1174.                 return true;
  1175.             }
  1176.             if (dayOrder == 0 && monthOrder == 1) {
  1177.                 order = ORDER_DM;
  1178.                 return true;
  1179.             }
  1180.             order = -1;
  1181.             return false;
  1182.         }
  1183.        
  1184.         //
  1185.         // Adjust the two-digit year if necessary.
  1186.         //
  1187.         private static int AdjustYear(ref DateTimeResult result, int year)
  1188.         {
  1189.             if (year < 100) {
  1190.                 year = result.calendar.ToFourDigitYear(year);
  1191.             }
  1192.             return (year);
  1193.         }
  1194.        
  1195.         private static bool SetDateYMD(ref DateTimeResult result, int year, int month, int day)
  1196.         {
  1197.             // Note, longer term these checks should be done at the end of the parse. This current
  1198.             // way of checking creates order dependence with parsing the era name.
  1199.             if (result.calendar.IsValidDay(year, month, day, result.era)) {
  1200.                 result.SetDate(year, month, day);
  1201.                 // YMD
  1202.                 return (true);
  1203.             }
  1204.             return (false);
  1205.         }
  1206.        
  1207.         private static bool SetDateMDY(ref DateTimeResult result, int month, int day, int year)
  1208.         {
  1209.             return (SetDateYMD(ref result, year, month, day));
  1210.         }
  1211.        
  1212.         private static bool SetDateDMY(ref DateTimeResult result, int day, int month, int year)
  1213.         {
  1214.             return (SetDateYMD(ref result, year, month, day));
  1215.         }
  1216.        
  1217.         private static bool SetDateYDM(ref DateTimeResult result, int year, int day, int month)
  1218.         {
  1219.             return (SetDateYMD(ref result, year, month, day));
  1220.         }
  1221.        
  1222.         // Processing teriminal case: DS.DX_NN
  1223.         private static bool GetDayOfNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1224.         {
  1225.            
  1226.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1227.                 // Multiple dates in the input string
  1228.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1229.                 return false;
  1230.             }
  1231.            
  1232.             int n1 = raw.GetNumber(0);
  1233.             int n2 = raw.GetNumber(1);
  1234.            
  1235.             int year = result.calendar.GetYear(DateTime.Now);
  1236.            
  1237.             int order;
  1238.             if (!GetMonthDayOrder(dtfi.MonthDayPattern, dtfi, out order)) {
  1239.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
  1240.                 return false;
  1241.             }
  1242.            
  1243.             if (order == ORDER_MD) {
  1244.                 // MD
  1245.                 if (SetDateYMD(ref result, year, n1, n2)) {
  1246.                     result.flags |= ParseFlags.HaveDate;
  1247.                     return true;
  1248.                 }
  1249.             }
  1250.             else {
  1251.                 // ORDER_DM
  1252.                 // DM
  1253.                 if (SetDateYMD(ref result, year, n2, n1)) {
  1254.                     result.flags |= ParseFlags.HaveDate;
  1255.                     return true;
  1256.                 }
  1257.             }
  1258.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1259.             return false;
  1260.         }
  1261.        
  1262.         // Processing teriminal case: DS.DX_NNN
  1263.         private static bool GetDayOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1264.         {
  1265.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1266.                 // Multiple dates in the input string
  1267.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1268.                 return false;
  1269.             }
  1270.            
  1271.             int n1 = raw.GetNumber(0);
  1272.             int n2 = raw.GetNumber(1);
  1273.             ;
  1274.             int n3 = raw.GetNumber(2);
  1275.            
  1276.             int order;
  1277.             if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, dtfi, out order)) {
  1278.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
  1279.                 return false;
  1280.             }
  1281.            
  1282.             if (order == ORDER_YMD) {
  1283.                 // YMD
  1284.                 if (SetDateYMD(ref result, AdjustYear(ref result, n1), n2, n3)) {
  1285.                     result.flags |= ParseFlags.HaveDate;
  1286.                     return true;
  1287.                 }
  1288.             }
  1289.             else if (order == ORDER_MDY) {
  1290.                 // MDY
  1291.                 if (SetDateMDY(ref result, n1, n2, AdjustYear(ref result, n3))) {
  1292.                     result.flags |= ParseFlags.HaveDate;
  1293.                     return true;
  1294.                 }
  1295.             }
  1296.             else if (order == ORDER_DMY) {
  1297.                 // DMY
  1298.                 if (SetDateDMY(ref result, n1, n2, AdjustYear(ref result, n3))) {
  1299.                     result.flags |= ParseFlags.HaveDate;
  1300.                     return true;
  1301.                 }
  1302.             }
  1303.             else if (order == ORDER_YDM) {
  1304.                 // YDM
  1305.                 if (SetDateYDM(ref result, AdjustYear(ref result, n1), n2, n3)) {
  1306.                     result.flags |= ParseFlags.HaveDate;
  1307.                     return true;
  1308.                 }
  1309.             }
  1310.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1311.             return false;
  1312.         }
  1313.        
  1314.         private static bool GetDayOfMN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1315.         {
  1316.            
  1317.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1318.                 // Multiple dates in the input string
  1319.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1320.                 return false;
  1321.             }
  1322.            
  1323.             // The interpretation is based on the MonthDayPattern and YearMonthPattern
  1324.             //
  1325.             // MonthDayPattern YearMonthPattern Interpretation
  1326.             // --------------- ---------------- ---------------
  1327.             // MMMM dd MMMM yyyy Day
  1328.             // MMMM dd yyyy MMMM Day
  1329.             // dd MMMM MMMM yyyy Year
  1330.             // dd MMMM yyyy MMMM Day
  1331.             //
  1332.             // In the first and last cases, it could be either or neither, but a day is a better default interpretation
  1333.             // than a 2 digit year.
  1334.            
  1335.             int monthDayOrder;
  1336.             if (!GetMonthDayOrder(dtfi.MonthDayPattern, dtfi, out monthDayOrder)) {
  1337.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
  1338.                 return false;
  1339.             }
  1340.             if (monthDayOrder == ORDER_DM) {
  1341.                 int yearMonthOrder;
  1342.                 if (!GetYearMonthOrder(dtfi.YearMonthPattern, dtfi, out yearMonthOrder)) {
  1343.                     result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.YearMonthPattern);
  1344.                     return false;
  1345.                 }
  1346.                 if (yearMonthOrder == ORDER_MY) {
  1347.                     if (!SetDateYMD(ref result, AdjustYear(ref result, raw.GetNumber(0)), raw.month, 1)) {
  1348.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1349.                         return false;
  1350.                     }
  1351.                     return true;
  1352.                 }
  1353.             }
  1354.            
  1355.             int currentYear = result.calendar.GetYear(DateTime.Now);
  1356.             if (!SetDateYMD(ref result, currentYear, raw.month, raw.GetNumber(0))) {
  1357.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1358.                 return false;
  1359.             }
  1360.             return true;
  1361.            
  1362.         }
  1363.        
  1364.         ////////////////////////////////////////////////////////////////////////
  1365.         // Actions:
  1366.         // Deal with the terminal state for Hebrew Month/Day pattern
  1367.         //
  1368.         ////////////////////////////////////////////////////////////////////////
  1369.        
  1370.         private static bool GetHebrewDayOfNM(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1371.         {
  1372.             int monthDayOrder;
  1373.             if (!GetMonthDayOrder(dtfi.MonthDayPattern, dtfi, out monthDayOrder)) {
  1374.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
  1375.                 return false;
  1376.             }
  1377.             result.Month = raw.month;
  1378.             if (monthDayOrder == ORDER_DM) {
  1379.                 if (result.calendar.IsValidDay(result.Year, result.Month, raw.GetNumber(0), result.era)) {
  1380.                     result.Day = raw.GetNumber(0);
  1381.                     return true;
  1382.                 }
  1383.             }
  1384.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1385.             return false;
  1386.         }
  1387.        
  1388.         private static bool GetDayOfNM(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1389.         {
  1390.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1391.                 // Multiple dates in the input string
  1392.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1393.                 return false;
  1394.             }
  1395.            
  1396.             // The interpretation is based on the MonthDayPattern and YearMonthPattern
  1397.             //
  1398.             // MonthDayPattern YearMonthPattern Interpretation
  1399.             // --------------- ---------------- ---------------
  1400.             // MMMM dd MMMM yyyy Day
  1401.             // MMMM dd yyyy MMMM Year
  1402.             // dd MMMM MMMM yyyy Day
  1403.             // dd MMMM yyyy MMMM Day
  1404.             //
  1405.             // In the first and last cases, it could be either or neither, but a day is a better default interpretation
  1406.             // than a 2 digit year.
  1407.            
  1408.             int monthDayOrder;
  1409.             if (!GetMonthDayOrder(dtfi.MonthDayPattern, dtfi, out monthDayOrder)) {
  1410.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
  1411.                 return false;
  1412.             }
  1413.             if (monthDayOrder == ORDER_MD) {
  1414.                 int yearMonthOrder;
  1415.                 if (!GetYearMonthOrder(dtfi.YearMonthPattern, dtfi, out yearMonthOrder)) {
  1416.                     result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.YearMonthPattern);
  1417.                     return false;
  1418.                 }
  1419.                 if (yearMonthOrder == ORDER_YM) {
  1420.                     if (!SetDateYMD(ref result, AdjustYear(ref result, raw.GetNumber(0)), raw.month, 1)) {
  1421.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1422.                         return false;
  1423.                     }
  1424.                     return true;
  1425.                 }
  1426.             }
  1427.            
  1428.             int currentYear = result.calendar.GetYear(DateTime.Now);
  1429.             if (!SetDateYMD(ref result, currentYear, raw.month, raw.GetNumber(0))) {
  1430.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1431.                 return false;
  1432.             }
  1433.             return true;
  1434.         }
  1435.        
  1436.         private static bool GetDayOfMNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1437.         {
  1438.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1439.                 // Multiple dates in the input string
  1440.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1441.                 return false;
  1442.             }
  1443.            
  1444.             int n1 = raw.GetNumber(0);
  1445.             int n2 = raw.GetNumber(1);
  1446.            
  1447.             int order;
  1448.             if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, dtfi, out order)) {
  1449.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
  1450.                 return false;
  1451.             }
  1452.             int year;
  1453.            
  1454.             if (order == ORDER_MDY) {
  1455.                 if (result.calendar.IsValidDay(year = AdjustYear(ref result, n2), raw.month, n1, result.era)) {
  1456.                     result.SetDate(year, raw.month, n1);
  1457.                     // MDY
  1458.                     result.flags |= ParseFlags.HaveDate;
  1459.                     return true;
  1460.                 }
  1461.                 else if (result.calendar.IsValidDay(year = AdjustYear(ref result, n1), raw.month, n2, result.era)) {
  1462.                     result.SetDate(year, raw.month, n2);
  1463.                     // YMD
  1464.                     result.flags |= ParseFlags.HaveDate;
  1465.                     return true;
  1466.                 }
  1467.             }
  1468.             else if (order == ORDER_YMD) {
  1469.                 if (result.calendar.IsValidDay(year = AdjustYear(ref result, n1), raw.month, n2, result.era)) {
  1470.                     result.SetDate(year, raw.month, n2);
  1471.                     // YMD
  1472.                     result.flags |= ParseFlags.HaveDate;
  1473.                     return true;
  1474.                 }
  1475.                 else if (result.calendar.IsValidDay(year = AdjustYear(ref result, n2), raw.month, n1, result.era)) {
  1476.                     result.SetDate(year, raw.month, n1);
  1477.                     // DMY
  1478.                     result.flags |= ParseFlags.HaveDate;
  1479.                     return true;
  1480.                 }
  1481.             }
  1482.             else if (order == ORDER_DMY) {
  1483.                 if (result.calendar.IsValidDay(year = AdjustYear(ref result, n2), raw.month, n1, result.era)) {
  1484.                     result.SetDate(year, raw.month, n1);
  1485.                     // DMY
  1486.                     result.flags |= ParseFlags.HaveDate;
  1487.                     return true;
  1488.                 }
  1489.                 else if (result.calendar.IsValidDay(year = AdjustYear(ref result, n1), raw.month, n2, result.era)) {
  1490.                     result.SetDate(year, raw.month, n2);
  1491.                     // YMD
  1492.                     result.flags |= ParseFlags.HaveDate;
  1493.                     return true;
  1494.                 }
  1495.             }
  1496.            
  1497.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1498.             return false;
  1499.         }
  1500.        
  1501.         private static bool GetDayOfYNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1502.         {
  1503.            
  1504.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1505.                 // Multiple dates in the input string
  1506.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1507.                 return false;
  1508.             }
  1509.            
  1510.             int n1 = raw.GetNumber(0);
  1511.             int n2 = raw.GetNumber(1);
  1512.             string pattern = dtfi.ShortDatePattern;
  1513.            
  1514.             // by the way, I think I've seen the opposite behavior in the tables.
  1515.             if (dtfi.CultureId == 1079) {
  1516.                 // 0x0437 = Georgian - Georgia (ka-GE)
  1517.                 // Very special case for ka-GE:
  1518.                 // Its short date patten is "dd.MM.yyyy" (ORDER_DMY).
  1519.                 // However, its long date pattern is "yyyy '\x10ec\x10da\x10d8\x10e1' dd MM, dddd" (ORDER_YDM)
  1520.                 pattern = dtfi.LongDatePattern;
  1521.             }
  1522.            
  1523.             // For compatability, don't throw if we can't determine the order, but default to YMD instead
  1524.             int order;
  1525.             if (GetYearMonthDayOrder(pattern, dtfi, out order) && order == ORDER_YDM) {
  1526.                 if (SetDateYMD(ref result, raw.year, n2, n1)) {
  1527.                     result.flags |= ParseFlags.HaveDate;
  1528.                     return true;
  1529.                     // Year + DM
  1530.                 }
  1531.             }
  1532.             else {
  1533.                 if (SetDateYMD(ref result, raw.year, n1, n2)) {
  1534.                     result.flags |= ParseFlags.HaveDate;
  1535.                     return true;
  1536.                     // Year + MD
  1537.                 }
  1538.             }
  1539.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1540.             return false;
  1541.         }
  1542.        
  1543.         private static bool GetDayOfNNY(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1544.         {
  1545.            
  1546.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1547.                 // Multiple dates in the input string
  1548.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1549.                 return false;
  1550.             }
  1551.            
  1552.             int n1 = raw.GetNumber(0);
  1553.             int n2 = raw.GetNumber(1);
  1554.            
  1555.             int order;
  1556.             if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, dtfi, out order)) {
  1557.                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
  1558.                 return false;
  1559.             }
  1560.            
  1561.             if (order == ORDER_MDY || order == ORDER_YMD) {
  1562.                 if (SetDateYMD(ref result, raw.year, n1, n2)) {
  1563.                     result.flags |= ParseFlags.HaveDate;
  1564.                     return true;
  1565.                     // MD + Year
  1566.                 }
  1567.             }
  1568.             else {
  1569.                 if (SetDateYMD(ref result, raw.year, n2, n1)) {
  1570.                     result.flags |= ParseFlags.HaveDate;
  1571.                     return true;
  1572.                     // DM + Year
  1573.                 }
  1574.             }
  1575.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1576.             return false;
  1577.         }
  1578.        
  1579.        
  1580.         private static bool GetDayOfYMN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1581.         {
  1582.            
  1583.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1584.                 // Multiple dates in the input string
  1585.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1586.                 return false;
  1587.             }
  1588.            
  1589.             if (SetDateYMD(ref result, raw.year, raw.month, raw.GetNumber(0))) {
  1590.                 result.flags |= ParseFlags.HaveDate;
  1591.                 return true;
  1592.             }
  1593.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1594.             return false;
  1595.         }
  1596.        
  1597.         private static bool GetDayOfYN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1598.         {
  1599.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1600.                 // Multiple dates in the input string
  1601.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1602.                 return false;
  1603.             }
  1604.            
  1605.             if (SetDateYMD(ref result, raw.year, raw.GetNumber(0), 1)) {
  1606.                 result.flags |= ParseFlags.HaveDate;
  1607.                 return true;
  1608.             }
  1609.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1610.             return false;
  1611.         }
  1612.        
  1613.         private static bool GetDayOfYM(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1614.         {
  1615.             if ((result.flags & ParseFlags.HaveDate) != 0) {
  1616.                 // Multiple dates in the input string
  1617.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1618.                 return false;
  1619.             }
  1620.            
  1621.             if (SetDateYMD(ref result, raw.year, raw.month, 1)) {
  1622.                 result.flags |= ParseFlags.HaveDate;
  1623.                 return true;
  1624.             }
  1625.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1626.             return false;
  1627.         }
  1628.        
  1629.         private static void AdjustTimeMark(DateTimeFormatInfo dtfi, ref DateTimeRawInfo raw)
  1630.         {
  1631.             // Specail case for culture which uses AM as empty string.
  1632.             // E.g. af-ZA (0x0436)
  1633.             // S1159 \x0000
  1634.             // S2359 nm
  1635.             // In this case, if we are parsing a string like "2005/09/14 12:23", we will assume this is in AM.
  1636.            
  1637.             if (raw.timeMark == TM.NotSet) {
  1638.                 if (dtfi.AMDesignator != null && dtfi.PMDesignator != null) {
  1639.                     if (dtfi.AMDesignator.Length == 0 && dtfi.PMDesignator.Length != 0) {
  1640.                         raw.timeMark = TM.AM;
  1641.                     }
  1642.                     if (dtfi.PMDesignator.Length == 0 && dtfi.AMDesignator.Length != 0) {
  1643.                         raw.timeMark = TM.PM;
  1644.                     }
  1645.                 }
  1646.             }
  1647.         }
  1648.        
  1649.         //
  1650.         // Adjust hour according to the time mark.
  1651.         //
  1652.         private static bool AdjustHour(ref int hour, TM timeMark)
  1653.         {
  1654.             if (timeMark != TM.NotSet) {
  1655.                
  1656.                 if (timeMark == TM.AM) {
  1657.                     if (hour < 0 || hour > 12) {
  1658.                         return false;
  1659.                     }
  1660.                     hour = (hour == 12) ? 0 : hour;
  1661.                 }
  1662.                 else {
  1663.                     if (hour < 0 || hour > 23) {
  1664.                         return false;
  1665.                     }
  1666.                     if (hour < 12) {
  1667.                         hour += 12;
  1668.                     }
  1669.                 }
  1670.             }
  1671.             return true;
  1672.         }
  1673.        
  1674.         private static bool GetTimeOfN(DateTimeFormatInfo dtfi, ref DateTimeResult result, ref DateTimeRawInfo raw)
  1675.         {
  1676.             if ((result.flags & ParseFlags.HaveTime) != 0) {
  1677.                 // Multiple times in the input string
  1678.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1679.                 return false;
  1680.             }
  1681.             //
  1682.             // In this case, we need a time mark. Check if so.
  1683.             //
  1684.             if (raw.timeMark == TM.NotSet) {
  1685.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1686.                 return false;
  1687.             }
  1688.             result.Hour = raw.GetNumber(0);
  1689.             result.flags |= ParseFlags.HaveTime;
  1690.             return true;
  1691.         }
  1692.        
  1693.         private static bool GetTimeOfNN(DateTimeFormatInfo dtfi, ref DateTimeResult result, ref DateTimeRawInfo raw)
  1694.         {
  1695.             BCLDebug.Assert(raw.numCount >= 2, "raw.numCount >= 2");
  1696.             if ((result.flags & ParseFlags.HaveTime) != 0) {
  1697.                 // Multiple times in the input string
  1698.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1699.                 return false;
  1700.             }
  1701.            
  1702.             result.Hour = raw.GetNumber(0);
  1703.             result.Minute = raw.GetNumber(1);
  1704.             result.flags |= ParseFlags.HaveTime;
  1705.             return true;
  1706.         }
  1707.        
  1708.         private static bool GetTimeOfNNN(DateTimeFormatInfo dtfi, ref DateTimeResult result, ref DateTimeRawInfo raw)
  1709.         {
  1710.             if ((result.flags & ParseFlags.HaveTime) != 0) {
  1711.                 // Multiple times in the input string
  1712.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1713.                 return false;
  1714.             }
  1715.             BCLDebug.Assert(raw.numCount >= 3, "raw.numCount >= 3");
  1716.             result.Hour = raw.GetNumber(0);
  1717.             result.Minute = raw.GetNumber(1);
  1718.             result.Second = raw.GetNumber(2);
  1719.             result.flags |= ParseFlags.HaveTime;
  1720.             return true;
  1721.         }
  1722.        
  1723.         //
  1724.         // Processing terminal state: A Date suffix followed by one number.
  1725.         //
  1726.         private static bool GetDateOfDSN(ref DateTimeResult result, ref DateTimeRawInfo raw)
  1727.         {
  1728.             if (raw.numCount != 1 || result.Day != -1) {
  1729.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1730.                 return false;
  1731.             }
  1732.             result.Day = raw.GetNumber(0);
  1733.             return true;
  1734.         }
  1735.        
  1736.         private static bool GetDateOfNDS(ref DateTimeResult result, ref DateTimeRawInfo raw)
  1737.         {
  1738.             if (result.Month == -1) {
  1739.                 //Should have a month suffix
  1740.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1741.                 return false;
  1742.             }
  1743.             if (result.Year != -1) {
  1744.                 // Aleady has a year suffix
  1745.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1746.                 return false;
  1747.             }
  1748.             result.Year = AdjustYear(ref result, raw.GetNumber(0));
  1749.             result.Day = 1;
  1750.             return true;
  1751.         }
  1752.        
  1753.         private static bool GetDateOfNNDS(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1754.         {
  1755.            
  1756.             // For partial CJK Dates, the only valid formats are with a specified year, followed by two numbers, which
  1757.             // will be the Month and Day, and with a specified Month, when the numbers are either the year and day or
  1758.             // day and year, depending on the short date pattern.
  1759.            
  1760.             if ((result.flags & ParseFlags.HaveYear) != 0) {
  1761.                 if (((result.flags & ParseFlags.HaveMonth) == 0) && ((result.flags & ParseFlags.HaveDay) == 0)) {
  1762.                     if (SetDateYMD(ref result, result.Year = AdjustYear(ref result, raw.year), raw.GetNumber(0), raw.GetNumber(1))) {
  1763.                         return true;
  1764.                     }
  1765.                 }
  1766.             }
  1767.             else if ((result.flags & ParseFlags.HaveMonth) != 0) {
  1768.                 if (((result.flags & ParseFlags.HaveYear) == 0) && ((result.flags & ParseFlags.HaveDay) == 0)) {
  1769.                     int order;
  1770.                     if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, dtfi, out order)) {
  1771.                         result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
  1772.                         return false;
  1773.                     }
  1774.                     int year;
  1775.                     if (order == ORDER_YMD) {
  1776.                         if (SetDateYMD(ref result, year = AdjustYear(ref result, raw.GetNumber(0)), result.Month, raw.GetNumber(1))) {
  1777.                             return true;
  1778.                         }
  1779.                     }
  1780.                     else {
  1781.                         if (SetDateYMD(ref result, year = AdjustYear(ref result, raw.GetNumber(1)), result.Month, raw.GetNumber(0))) {
  1782.                             return true;
  1783.                         }
  1784.                     }
  1785.                 }
  1786.             }
  1787.             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1788.             return false;
  1789.         }
  1790.        
  1791.         //
  1792.         // A date suffix is found, use this method to put the number into the result.
  1793.         //
  1794.         private static bool ProcessDateTimeSuffix(ref DateTimeResult result, ref DateTimeRawInfo raw, ref DateTimeToken dtok)
  1795.         {
  1796.             switch (dtok.suffix) {
  1797.                 case TokenType.SEP_YearSuff:
  1798.                     if ((result.flags & ParseFlags.HaveYear) != 0) {
  1799.                         return false;
  1800.                     }
  1801.                     result.flags |= ParseFlags.HaveYear;
  1802.                     result.Year = raw.year = dtok.num;
  1803.                     break;
  1804.                 case TokenType.SEP_MonthSuff:
  1805.                     if ((result.flags & ParseFlags.HaveMonth) != 0) {
  1806.                         return false;
  1807.                     }
  1808.                     result.flags |= ParseFlags.HaveMonth;
  1809.                     result.Month = raw.month = dtok.num;
  1810.                     break;
  1811.                 case TokenType.SEP_DaySuff:
  1812.                     if ((result.flags & ParseFlags.HaveDay) != 0) {
  1813.                         return false;
  1814.                     }
  1815.                     result.flags |= ParseFlags.HaveDay;
  1816.                     result.Day = dtok.num;
  1817.                     break;
  1818.                 case TokenType.SEP_HourSuff:
  1819.                     if ((result.flags & ParseFlags.HaveHour) != 0) {
  1820.                         return false;
  1821.                     }
  1822.                     result.flags |= ParseFlags.HaveHour;
  1823.                     result.Hour = dtok.num;
  1824.                     break;
  1825.                 case TokenType.SEP_MinuteSuff:
  1826.                     if ((result.flags & ParseFlags.HaveMinute) != 0) {
  1827.                         return false;
  1828.                     }
  1829.                     result.flags |= ParseFlags.HaveMinute;
  1830.                     result.Minute = dtok.num;
  1831.                     break;
  1832.                 case TokenType.SEP_SecondSuff:
  1833.                     if ((result.flags & ParseFlags.HaveSecond) != 0) {
  1834.                         return false;
  1835.                     }
  1836.                     result.flags |= ParseFlags.HaveSecond;
  1837.                     result.Second = dtok.num;
  1838.                     break;
  1839.             }
  1840.             return true;
  1841.            
  1842.         }
  1843.        
  1844.         ////////////////////////////////////////////////////////////////////////
  1845.         //
  1846.         // Actions:
  1847.         // This is used by DateTime.Parse().
  1848.         // Process the terminal state for the Hebrew calendar parsing.
  1849.         //
  1850.         ////////////////////////////////////////////////////////////////////////
  1851.        
  1852.         static internal bool ProcessHebrewTerminalState(DS dps, ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1853.         {
  1854.             // The following are accepted terminal state for Hebrew date.
  1855.             switch (dps) {
  1856.                 case DS.DX_MNN:
  1857.                     // Deal with the default long/short date format when the year number is ambigous (i.e. year < 100).
  1858.                     raw.year = raw.GetNumber(1);
  1859.                     if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, true)) {
  1860.                         result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  1861.                         return false;
  1862.                     }
  1863.                     if (!GetDayOfMNN(ref result, ref raw, dtfi)) {
  1864.                         return false;
  1865.                     }
  1866.                     break;
  1867.                 case DS.DX_YMN:
  1868.                     // Deal with the default long/short date format when the year number is NOT ambigous (i.e. year >= 100).
  1869.                     if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, true)) {
  1870.                         result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  1871.                         return false;
  1872.                     }
  1873.                     if (!GetDayOfYMN(ref result, ref raw, dtfi)) {
  1874.                         return false;
  1875.                     }
  1876.                     break;
  1877.                 case DS.DX_NM:
  1878.                     // Deal with Month/Day pattern.
  1879.                     result.Year = dtfi.Calendar.GetYear(DateTime.Now);
  1880.                     if (!dtfi.YearMonthAdjustment(ref result.Year, ref raw.month, true)) {
  1881.                         result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  1882.                         return false;
  1883.                     }
  1884.                     if (!GetHebrewDayOfNM(ref result, ref raw, dtfi)) {
  1885.                         return false;
  1886.                     }
  1887.                     break;
  1888.                 case DS.DX_YM:
  1889.                     // Deal with Year/Month pattern.
  1890.                     if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, true)) {
  1891.                         result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  1892.                         return false;
  1893.                     }
  1894.                     if (!GetDayOfYM(ref result, ref raw, dtfi)) {
  1895.                         return false;
  1896.                     }
  1897.                     break;
  1898.                 case DS.TX_N:
  1899.                     // Deal hour + AM/PM
  1900.                     if (!GetTimeOfN(dtfi, ref result, ref raw)) {
  1901.                         return false;
  1902.                     }
  1903.                     break;
  1904.                 case DS.TX_NN:
  1905.                     if (!GetTimeOfNN(dtfi, ref result, ref raw)) {
  1906.                         return false;
  1907.                     }
  1908.                     break;
  1909.                 case DS.TX_NNN:
  1910.                     if (!GetTimeOfNNN(dtfi, ref result, ref raw)) {
  1911.                         return false;
  1912.                     }
  1913.                     break;
  1914.                 default:
  1915.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  1916.                     return false;
  1917.                
  1918.             }
  1919.             if (dps > DS.ERROR) {
  1920.                 //
  1921.                 // We have reached a terminal state. Reset the raw num count.
  1922.                 //
  1923.                 raw.numCount = 0;
  1924.             }
  1925.             return true;
  1926.         }
  1927.        
  1928.         //
  1929.         // A terminal state has been reached, call the appropriate function to fill in the parsing result.
  1930.         // Return true if the state is a terminal state.
  1931.         //
  1932.         static internal bool ProcessTerminaltState(DS dps, ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
  1933.         {
  1934.            
  1935.             switch (dps) {
  1936.                 case DS.DX_NN:
  1937.                     if (!GetDayOfNN(ref result, ref raw, dtfi)) {
  1938.                         return false;
  1939.                     }
  1940.                     break;
  1941.                 case DS.DX_NNN:
  1942.                     if (!GetDayOfNNN(ref result, ref raw, dtfi)) {
  1943.                         return false;
  1944.                     }
  1945.                     break;
  1946.                 case DS.DX_MN:
  1947.                     if (!GetDayOfMN(ref result, ref raw, dtfi)) {
  1948.                         return false;
  1949.                     }
  1950.                     break;
  1951.                 case DS.DX_NM:
  1952.                     if (!GetDayOfNM(ref result, ref raw, dtfi)) {
  1953.                         return false;
  1954.                     }
  1955.                     break;
  1956.                 case DS.DX_MNN:
  1957.                     if (!GetDayOfMNN(ref result, ref raw, dtfi)) {
  1958.                         return false;
  1959.                     }
  1960.                     break;
  1961.                 case DS.DX_DS:
  1962.                     // The result has got the correct value. No need to process.
  1963.                     break;
  1964.                 case DS.DX_YNN:
  1965.                     if (!GetDayOfYNN(ref result, ref raw, dtfi)) {
  1966.                         return false;
  1967.                     }
  1968.                     break;
  1969.                 case DS.DX_NNY:
  1970.                     if (!GetDayOfNNY(ref result, ref raw, dtfi)) {
  1971.                         return false;
  1972.                     }
  1973.                     break;
  1974.                 case DS.DX_YMN:
  1975.                     if (!GetDayOfYMN(ref result, ref raw, dtfi)) {
  1976.                         return false;
  1977.                     }
  1978.                     break;
  1979.                 case DS.DX_YN:
  1980.                     if (!GetDayOfYN(ref result, ref raw, dtfi)) {
  1981.                         return false;
  1982.                     }
  1983.                     break;
  1984.                 case DS.DX_YM:
  1985.                     if (!GetDayOfYM(ref result, ref raw, dtfi)) {
  1986.                         return false;
  1987.                     }
  1988.                     break;
  1989.                 case DS.TX_N:
  1990.                     if (!GetTimeOfN(dtfi, ref result, ref raw)) {
  1991.                         return false;
  1992.                     }
  1993.                     break;
  1994.                 case DS.TX_NN:
  1995.                     if (!GetTimeOfNN(dtfi, ref result, ref raw)) {
  1996.                         return false;
  1997.                     }
  1998.                     break;
  1999.                 case DS.TX_NNN:
  2000.                     if (!GetTimeOfNNN(dtfi, ref result, ref raw)) {
  2001.                         return false;
  2002.                     }
  2003.                     break;
  2004.                 case DS.TX_TS:
  2005.                     // The result has got the correct value. Nothing to do.
  2006.                     break;
  2007.                 case DS.DX_DSN:
  2008.                     if (!GetDateOfDSN(ref result, ref raw)) {
  2009.                         return false;
  2010.                     }
  2011.                     break;
  2012.                 case DS.DX_NDS:
  2013.                     if (!GetDateOfNDS(ref result, ref raw)) {
  2014.                         return false;
  2015.                     }
  2016.                     break;
  2017.                 case DS.DX_NNDS:
  2018.                     if (!GetDateOfNNDS(ref result, ref raw, dtfi)) {
  2019.                         return false;
  2020.                     }
  2021.                     break;
  2022.             }
  2023.            
  2024.             if (dps > DS.ERROR) {
  2025.                 //
  2026.                 // We have reached a terminal state. Reset the raw num count.
  2027.                 //
  2028.                 raw.numCount = 0;
  2029.             }
  2030.             return true;
  2031.         }
  2032.        
  2033.         static internal DateTime Parse(string s, DateTimeFormatInfo dtfi, DateTimeStyles styles)
  2034.         {
  2035.             DateTimeResult result = new DateTimeResult();
  2036.             // The buffer to store the parsing result.
  2037.             result.Init();
  2038.             if (TryParse(s, dtfi, styles, ref result)) {
  2039.                 return result.parsedDate;
  2040.             }
  2041.             else {
  2042.                 throw GetDateTimeParseException(ref result);
  2043.             }
  2044.         }
  2045.        
  2046.         static internal bool TryParse(string s, DateTimeFormatInfo dtfi, DateTimeStyles styles, out DateTime result)
  2047.         {
  2048.             result = DateTime.MinValue;
  2049.             DateTimeResult resultData = new DateTimeResult();
  2050.             // The buffer to store the parsing result.
  2051.             resultData.Init();
  2052.             if (TryParse(s, dtfi, styles, ref resultData)) {
  2053.                 result = resultData.parsedDate;
  2054.                 return true;
  2055.             }
  2056.             return false;
  2057.         }
  2058.        
  2059.         //
  2060.         // This is the real method to do the parsing work.
  2061.         //
  2062.         static internal bool TryParse(string s, DateTimeFormatInfo dtfi, DateTimeStyles styles, ref DateTimeResult result)
  2063.         {
  2064.             if (s == null) {
  2065.                 result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "s");
  2066.                 return false;
  2067.             }
  2068.             if (s.Length == 0) {
  2069.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2070.                 return false;
  2071.             }
  2072.            
  2073.             BCLDebug.Assert(dtfi != null, "dtfi == null");
  2074.            
  2075.             DateTime time;
  2076.             //
  2077.             // First try the predefined format.
  2078.             //
  2079.            
  2080.             DS dps = DS.BEGIN;
  2081.             // Date Parsing State.
  2082.             bool reachTerminalState = false;
  2083.            
  2084.             DateTimeToken dtok = new DateTimeToken();
  2085.             // The buffer to store the parsing token.
  2086.             dtok.suffix = TokenType.SEP_Unk;
  2087.             DateTimeRawInfo raw = new DateTimeRawInfo();
  2088.             // The buffer to store temporary parsing information.
  2089.             unsafe {
  2090.                 Int32* numberPointer = stackalloc Int32[3];
  2091.                 raw.Init(numberPointer);
  2092.             }
  2093.             result.calendar = dtfi.Calendar;
  2094.             result.era = Calendar.CurrentEra;
  2095.            
  2096.             //
  2097.             // The string to be parsed. Use a __DTString wrapper so that we can trace the index which
  2098.             // indicates the begining of next token.
  2099.             //
  2100.             __DTString str = new __DTString(s, dtfi);
  2101.            
  2102.             str.GetNext();
  2103.            
  2104.             //
  2105.             // The following loop will break out when we reach the end of the str.
  2106.             //
  2107.             do {
  2108.                 //
  2109.                 // Call the lexer to get the next token.
  2110.                 //
  2111.                 // If we find a era in Lex(), the era value will be in raw.era.
  2112.                 if (!Lex(dps, ref str, ref dtok, ref raw, ref result, ref dtfi)) {
  2113.                     return false;
  2114.                 }
  2115.                
  2116.                 //
  2117.                 // If the token is not unknown, process it.
  2118.                 // Otherwise, just discard it.
  2119.                 //
  2120.                 if (dtok.dtt != DTT.Unk) {
  2121.                     //
  2122.                     // Check if we got any CJK Date/Time suffix.
  2123.                     // Since the Date/Time suffix tells us the number belongs to year/month/day/hour/minute/second,
  2124.                     // store the number in the appropriate field in the result.
  2125.                     //
  2126.                     if (dtok.suffix != TokenType.SEP_Unk) {
  2127.                         if (!ProcessDateTimeSuffix(ref result, ref raw, ref dtok)) {
  2128.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2129.                             return false;
  2130.                         }
  2131.                        
  2132.                         dtok.suffix = TokenType.SEP_Unk;
  2133.                         // Reset suffix to SEP_Unk;
  2134.                     }
  2135.                    
  2136.                     if (dtok.dtt == DTT.NumLocalTimeMark) {
  2137.                         if (dps == DS.D_YNd || dps == DS.D_YN) {
  2138.                             return (ParseISO8601(ref raw, ref str, styles, ref result));
  2139.                         }
  2140.                         else {
  2141.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2142.                             return false;
  2143.                         }
  2144.                     }
  2145.                    
  2146.                     //
  2147.                     // Advance to the next state, and continue
  2148.                     //
  2149.                     dps = dateParsingStates[(int)dps][(int)dtok.dtt];
  2150.                    
  2151.                     if (dps == DS.ERROR) {
  2152.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2153.                         return false;
  2154.                     }
  2155.                     else if (dps > DS.ERROR) {
  2156.                         if ((dtfi.FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0) {
  2157.                             if (!ProcessHebrewTerminalState(dps, ref result, ref raw, dtfi)) {
  2158.                                 return false;
  2159.                             }
  2160.                         }
  2161.                         else {
  2162.                             if (!ProcessTerminaltState(dps, ref result, ref raw, dtfi)) {
  2163.                                 return false;
  2164.                             }
  2165.                         }
  2166.                         reachTerminalState = true;
  2167.                        
  2168.                         //
  2169.                         // If we have reached a terminal state, start over from DS.BEGIN again.
  2170.                         // For example, when we parsed "1999-12-23 13:30", we will reach a terminal state at "1999-12-23",
  2171.                         // and we start over so we can continue to parse "12:30".
  2172.                         //
  2173.                         dps = DS.BEGIN;
  2174.                     }
  2175.                 }
  2176.             }
  2177.             while (dtok.dtt != DTT.End && dtok.dtt != DTT.NumEnd && dtok.dtt != DTT.MonthEnd);
  2178.            
  2179.             if (!reachTerminalState) {
  2180.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2181.                 return false;
  2182.             }
  2183.            
  2184.             AdjustTimeMark(dtfi, ref raw);
  2185.             if (!AdjustHour(ref result.Hour, raw.timeMark)) {
  2186.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2187.                 return false;
  2188.             }
  2189.            
  2190.             // Check if the parased string only contains hour/minute/second values.
  2191.             bool bTimeOnly = (result.Year == -1 && result.Month == -1 && result.Day == -1);
  2192.            
  2193.             //
  2194.             // Check if any year/month/day is missing in the parsing string.
  2195.             // If yes, get the default value from today's date.
  2196.             //
  2197.             CheckDefaultDateTime(ref result, ref result.calendar, styles);
  2198.            
  2199.             if (!result.calendar.TryToDateTime(result.Year, result.Month, result.Day, result.Hour, result.Minute, result.Second, 0, result.era, out time)) {
  2200.                 result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  2201.                 return false;
  2202.             }
  2203.             if (raw.fraction > 0) {
  2204.                 time = time.AddTicks((long)Math.Round(raw.fraction * Calendar.TicksPerSecond));
  2205.             }
  2206.            
  2207.             //
  2208.             // We have to check day of week before we adjust to the time zone.
  2209.             // Otherwise, the value of day of week may change after adjustting to the time zone.
  2210.             //
  2211.             if (raw.dayOfWeek != -1) {
  2212.                 //
  2213.                 // Check if day of week is correct.
  2214.                 //
  2215.                 if (raw.dayOfWeek != (int)result.calendar.GetDayOfWeek(time)) {
  2216.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDayOfWeek", null);
  2217.                     return false;
  2218.                 }
  2219.             }
  2220.            
  2221.             result.parsedDate = time;
  2222.            
  2223.             if (!DetermineTimeZoneAdjustments(ref result, styles, bTimeOnly)) {
  2224.                 return false;
  2225.             }
  2226.            
  2227.             return true;
  2228.         }
  2229.        
  2230.         // Handles time zone adjustments and sets DateTimeKind values as required by the styles
  2231.         private static bool DetermineTimeZoneAdjustments(ref DateTimeResult result, DateTimeStyles styles, bool bTimeOnly)
  2232.         {
  2233.            
  2234.             // The flags AssumeUniveral and AssumeLocal only apply when the input does not have a time zone
  2235.             if ((result.flags & ParseFlags.TimeZoneUsed) == 0) {
  2236.                
  2237.                 // If AssumeLocal or AssumeLocal is used, there will always be a kind specified. As in the
  2238.                 // case when a time zone is present, it will default to being local unless AdjustToUniversal
  2239.                 // is present. These comparisons determine whether setting the kind is sufficient, or if a
  2240.                 // time zone adjustment is required. For consistentcy with the rest of parsing, it is desirable
  2241.                 // to fall through to the Adjust methods below, so that there is consist handling of boundary
  2242.                 // cases like wrapping around on time-only dates and temporarily allowing an adjusted date
  2243.                 // to exceed DateTime.MaxValue
  2244.                 if ((styles & DateTimeStyles.AssumeLocal) != 0) {
  2245.                     if ((styles & DateTimeStyles.AdjustToUniversal) != 0) {
  2246.                         result.flags |= ParseFlags.TimeZoneUsed;
  2247.                         result.timeZoneOffset = TimeZone.CurrentTimeZone.GetUtcOffset(result.parsedDate);
  2248.                     }
  2249.                     else {
  2250.                         result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Local);
  2251.                         return true;
  2252.                     }
  2253.                 }
  2254.                 else if ((styles & DateTimeStyles.AssumeUniversal) != 0) {
  2255.                     if ((styles & DateTimeStyles.AdjustToUniversal) != 0) {
  2256.                         result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Utc);
  2257.                         return true;
  2258.                     }
  2259.                     else {
  2260.                         result.flags |= ParseFlags.TimeZoneUsed;
  2261.                         result.timeZoneOffset = TimeSpan.Zero;
  2262.                     }
  2263.                 }
  2264.                 else {
  2265.                     // No time zone and no Assume flags, so DateTimeKind.Unspecified is fine
  2266.                     BCLDebug.Assert(result.parsedDate.Kind == DateTimeKind.Unspecified, "result.parsedDate.Kind == DateTimeKind.Unspecified");
  2267.                     return true;
  2268.                 }
  2269.             }
  2270.            
  2271.             if (((styles & DateTimeStyles.RoundtripKind) != 0) && ((result.flags & ParseFlags.TimeZoneUtc) != 0)) {
  2272.                 result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Utc);
  2273.                 return true;
  2274.             }
  2275.            
  2276.             if ((styles & DateTimeStyles.AdjustToUniversal) != 0) {
  2277.                 return (AdjustTimeZoneToUniversal(ref result));
  2278.             }
  2279.             return (AdjustTimeZoneToLocal(ref result, bTimeOnly));
  2280.         }
  2281.        
  2282.         //
  2283.         // Adjust the specified time to universal time based on the supplied timezone.
  2284.         // E.g. when parsing "2001/06/08 14:00-07:00",
  2285.         // the time is 2001/06/08 14:00, and timeZoneOffset = -07:00.
  2286.         // The result will be "2001/06/08 21:00"
  2287.         //
  2288.         private static bool AdjustTimeZoneToUniversal(ref DateTimeResult result)
  2289.         {
  2290.             long resultTicks = result.parsedDate.Ticks;
  2291.             resultTicks -= result.timeZoneOffset.Ticks;
  2292.             if (resultTicks < 0) {
  2293.                 resultTicks += Calendar.TicksPerDay;
  2294.             }
  2295.            
  2296.             if (resultTicks < DateTime.MinTicks || resultTicks > DateTime.MaxTicks) {
  2297.                 result.SetFailure(ParseFailureKind.Format, "Format_DateOutOfRange", null);
  2298.                 return false;
  2299.             }
  2300.             result.parsedDate = new DateTime(resultTicks, DateTimeKind.Utc);
  2301.             return true;
  2302.         }
  2303.        
  2304.         //
  2305.         // Adjust the specified time to universal time based on the supplied timezone,
  2306.         // and then convert to local time.
  2307.         // E.g. when parsing "2001/06/08 14:00-04:00", and local timezone is GMT-7.
  2308.         // the time is 2001/06/08 14:00, and timeZoneOffset = -05:00.
  2309.         // The result will be "2001/06/08 11:00"
  2310.         //
  2311.         private static bool AdjustTimeZoneToLocal(ref DateTimeResult result, bool bTimeOnly)
  2312.         {
  2313.             long resultTicks = result.parsedDate.Ticks;
  2314.             // Convert to local ticks
  2315.             CurrentSystemTimeZone tz = (CurrentSystemTimeZone)TimeZone.CurrentTimeZone;
  2316.             bool isAmbiguousLocalDst = false;
  2317.             if (resultTicks < Calendar.TicksPerDay) {
  2318.                 //
  2319.                 // This is time of day.
  2320.                 //
  2321.                
  2322.                 // Adjust timezone.
  2323.                 resultTicks -= result.timeZoneOffset.Ticks;
  2324.                 // If the time is time of day, use the current timezone offset.
  2325.                 resultTicks += tz.GetUtcOffset(bTimeOnly ? DateTime.Now : result.parsedDate).Ticks;
  2326.                
  2327.                 if (resultTicks < 0) {
  2328.                     resultTicks += Calendar.TicksPerDay;
  2329.                 }
  2330.             }
  2331.             else {
  2332.                 // Adjust timezone to GMT.
  2333.                 resultTicks -= result.timeZoneOffset.Ticks;
  2334.                 if (resultTicks < DateTime.MinTicks || resultTicks > DateTime.MaxTicks) {
  2335.                     // If the result ticks is greater than DateTime.MaxValue, we can not create a DateTime from this ticks.
  2336.                     // In this case, keep using the old code.
  2337.                     resultTicks += tz.GetUtcOffset(result.parsedDate).Ticks;
  2338.                 }
  2339.                 else {
  2340.                     // Convert the GMT time to local time.
  2341.                     resultTicks += tz.GetUtcOffsetFromUniversalTime(new DateTime(resultTicks), ref isAmbiguousLocalDst);
  2342.                 }
  2343.             }
  2344.             if (resultTicks < DateTime.MinTicks || resultTicks > DateTime.MaxTicks) {
  2345.                 result.parsedDate = DateTime.MinValue;
  2346.                 result.SetFailure(ParseFailureKind.Format, "Format_DateOutOfRange", null);
  2347.                 return false;
  2348.             }
  2349.             result.parsedDate = new DateTime(resultTicks, DateTimeKind.Local, isAmbiguousLocalDst);
  2350.             return true;
  2351.         }
  2352.        
  2353.         //
  2354.         // Parse the ISO8601 format string found during Parse();
  2355.         //
  2356.         //
  2357.         private static bool ParseISO8601(ref DateTimeRawInfo raw, ref __DTString str, DateTimeStyles styles, ref DateTimeResult result)
  2358.         {
  2359.             if (raw.year < 0 || raw.GetNumber(0) < 0 || raw.GetNumber(1) < 0) {
  2360.             }
  2361.             str.Index--;
  2362.             int hour;
  2363.             int minute;
  2364.             int second = 0;
  2365.             double partSecond = 0;
  2366.            
  2367.             str.SkipWhiteSpaces();
  2368.             if (!ParseDigits(ref str, 2, out hour)) {
  2369.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2370.                 return false;
  2371.             }
  2372.             str.SkipWhiteSpaces();
  2373.             if (!str.Match(':')) {
  2374.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2375.                 return false;
  2376.             }
  2377.             str.SkipWhiteSpaces();
  2378.             if (!ParseDigits(ref str, 2, out minute)) {
  2379.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2380.                 return false;
  2381.             }
  2382.             str.SkipWhiteSpaces();
  2383.             if (str.Match(':')) {
  2384.                 str.SkipWhiteSpaces();
  2385.                 if (!ParseDigits(ref str, 2, out second)) {
  2386.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2387.                     return false;
  2388.                 }
  2389.                 if (str.Match('.')) {
  2390.                     if (!ParseFraction(ref str, out partSecond)) {
  2391.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2392.                         return false;
  2393.                     }
  2394.                     str.Index--;
  2395.                 }
  2396.                 str.SkipWhiteSpaces();
  2397.             }
  2398.             if (str.GetNext()) {
  2399.                 char ch = str.GetChar();
  2400.                 if (ch == '+' || ch == '-') {
  2401.                     result.flags |= ParseFlags.TimeZoneUsed;
  2402.                     if (!ParseTimeZone(ref str, ref result.timeZoneOffset)) {
  2403.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2404.                         return false;
  2405.                     }
  2406.                 }
  2407.                 else if (ch == 'Z' || ch == 'z') {
  2408.                     result.flags |= ParseFlags.TimeZoneUsed;
  2409.                     result.timeZoneOffset = TimeSpan.Zero;
  2410.                     result.flags |= ParseFlags.TimeZoneUtc;
  2411.                 }
  2412.                 else {
  2413.                     str.Index--;
  2414.                 }
  2415.                 str.SkipWhiteSpaces();
  2416.                 if (str.Match('#')) {
  2417.                     if (!VerifyValidPunctuation(ref str)) {
  2418.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2419.                         return false;
  2420.                     }
  2421.                     str.SkipWhiteSpaces();
  2422.                 }
  2423.                 if (str.Match('\0')) {
  2424.                     if (!VerifyValidPunctuation(ref str)) {
  2425.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2426.                         return false;
  2427.                     }
  2428.                 }
  2429.                 if (str.GetNext()) {
  2430.                     // If this is true, there were non-white space characters remaining in the DateTime
  2431.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  2432.                     return false;
  2433.                 }
  2434.             }
  2435.            
  2436.             DateTime time;
  2437.             Calendar calendar = GregorianCalendar.GetDefaultInstance();
  2438.             if (!calendar.TryToDateTime(raw.year, raw.GetNumber(0), raw.GetNumber(1), hour, minute, second, 0, result.era, out time)) {
  2439.                 result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  2440.                 return false;
  2441.             }
  2442.            
  2443.             time = time.AddTicks((long)Math.Round(partSecond * Calendar.TicksPerSecond));
  2444.             result.parsedDate = time;
  2445.             if (!DetermineTimeZoneAdjustments(ref result, styles, false)) {
  2446.                 return false;
  2447.             }
  2448.             return true;
  2449.         }
  2450.        
  2451.        
  2452.         ////////////////////////////////////////////////////////////////////////
  2453.         //
  2454.         // Actions:
  2455.         // Parse the current word as a Hebrew number.
  2456.         // This is used by DateTime.ParseExact().
  2457.         //
  2458.         ////////////////////////////////////////////////////////////////////////
  2459.        
  2460.         static internal bool MatchHebrewDigits(ref __DTString str, int digitLen, out int number)
  2461.         {
  2462.             number = 0;
  2463.            
  2464.             // Create a context object so that we can parse the Hebrew number text character by character.
  2465.             HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);
  2466.            
  2467.             // Set this to ContinueParsing so that we will run the following while loop in the first time.
  2468.             HebrewNumberParsingState state = HebrewNumberParsingState.ContinueParsing;
  2469.            
  2470.             while (state == HebrewNumberParsingState.ContinueParsing && str.GetNext()) {
  2471.                 state = HebrewNumber.ParseByChar(str.GetChar(), ref context);
  2472.             }
  2473.            
  2474.             if (state == HebrewNumberParsingState.FoundEndOfHebrewNumber) {
  2475.                 // If we have reached a terminal state, update the result and returns.
  2476.                 number = context.result;
  2477.                 return (true);
  2478.             }
  2479.            
  2480.             // If we run out of the character before reaching FoundEndOfHebrewNumber, or
  2481.             // the state is InvalidHebrewNumber or ContinueParsing, we fail to match a Hebrew number.
  2482.             // Return an error.
  2483.             return false;
  2484.         }
  2485.        
  2486. /*=================================ParseDigits==================================
  2487.         **Action: Parse the number string in __DTString that are formatted using
  2488.         **        the following patterns:
  2489.         **        "0", "00", and "000..0"
  2490.         **Returns: the integer value
  2491.         **Arguments:    str: a __DTString.  The parsing will start from the
  2492.         **              next character after str.Index.
  2493.         **Exceptions: FormatException if error in parsing number.
  2494.         ==============================================================================*/       
  2495.        
  2496.         static internal bool ParseDigits(ref __DTString str, int digitLen, out int result)
  2497.         {
  2498.             if (digitLen == 1) {
  2499.                 // 1 really means 1 or 2 for this call
  2500.                 return ParseDigits(ref str, 1, 2, out result);
  2501.             }
  2502.             else {
  2503.                 return ParseDigits(ref str, digitLen, digitLen, out result);
  2504.             }
  2505.         }
  2506.        
  2507.         static internal bool ParseDigits(ref __DTString str, int minDigitLen, int maxDigitLen, out int result)
  2508.         {
  2509.             BCLDebug.Assert(minDigitLen > 0, "minDigitLen > 0");
  2510.             BCLDebug.Assert(maxDigitLen < 9, "maxDigitLen < 9");
  2511.             BCLDebug.Assert(minDigitLen <= maxDigitLen, "minDigitLen <= maxDigitLen");
  2512.             result = 0;
  2513.             int startingIndex = str.Index;
  2514.             int tokenLength = 0;
  2515.             while (tokenLength < maxDigitLen) {
  2516.                 if (!str.GetNextDigit()) {
  2517.                     str.Index--;
  2518.                     break;
  2519.                 }
  2520.                 result = result * 10 + str.GetDigit();
  2521.                 tokenLength++;
  2522.             }
  2523.             if (tokenLength < minDigitLen) {
  2524.                 str.Index = startingIndex;
  2525.                 return false;
  2526.             }
  2527.             return true;
  2528.         }
  2529.        
  2530. /*=================================ParseFractionExact==================================
  2531.         **Action: Parse the number string in __DTString that are formatted using
  2532.         **        the following patterns:
  2533.         **        "0", "00", and "000..0"
  2534.         **Returns: the fraction value
  2535.         **Arguments:    str: a __DTString.  The parsing will start from the
  2536.         **              next character after str.Index.
  2537.         **Exceptions: FormatException if error in parsing number.
  2538.         ==============================================================================*/       
  2539.        
  2540.         private static bool ParseFractionExact(ref __DTString str, int maxDigitLen, ref double result)
  2541.         {
  2542.             if (!str.GetNextDigit()) {
  2543.                 str.Index--;
  2544.                 return false;
  2545.             }
  2546.             result = str.GetDigit();
  2547.            
  2548.             int digitLen = 1;
  2549.             for (; digitLen < maxDigitLen; digitLen++) {
  2550.                 if (!str.GetNextDigit()) {
  2551.                     str.Index--;
  2552.                     break;
  2553.                 }
  2554.                 result = result * 10 + str.GetDigit();
  2555.             }
  2556.            
  2557.             result = ((double)result / Math.Pow(10, digitLen));
  2558.             return (digitLen == maxDigitLen);
  2559.         }
  2560.        
  2561. /*=================================ParseSign==================================
  2562.         **Action: Parse a positive or a negative sign.
  2563.         **Returns:      true if postive sign.  flase if negative sign.
  2564.         **Arguments:    str: a __DTString.  The parsing will start from the
  2565.         **              next character after str.Index.
  2566.         **Exceptions:  FormatException if end of string is encountered or a sign
  2567.         **              symbol is not found.
  2568.         ==============================================================================*/       
  2569.        
  2570.         private static bool ParseSign(ref __DTString str, ref bool result)
  2571.         {
  2572.             if (!str.GetNext()) {
  2573.                 // A sign symbol ('+' or '-') is expected. However, end of string is encountered.
  2574.                 return false;
  2575.             }
  2576.             char ch = str.GetChar();
  2577.             if (ch == '+') {
  2578.                 result = true;
  2579.                 return (true);
  2580.             }
  2581.             else if (ch == '-') {
  2582.                 result = false;
  2583.                 return (true);
  2584.             }
  2585.             // A sign symbol ('+' or '-') is expected.
  2586.             return false;
  2587.         }
  2588.        
  2589. /*=================================ParseTimeZoneOffset==================================
  2590.         **Action: Parse the string formatted using "z", "zz", "zzz" in DateTime.Format().
  2591.         **Returns: the TimeSpan for the parsed timezone offset.
  2592.         **Arguments:    str: a __DTString.  The parsing will start from the
  2593.         **              next character after str.Index.
  2594.         **              len: the repeated number of the "z"
  2595.         **Exceptions: FormatException if errors in parsing.
  2596.         ==============================================================================*/       
  2597.        
  2598.         private static bool ParseTimeZoneOffset(ref __DTString str, int len, ref TimeSpan result)
  2599.         {
  2600.             bool isPositive = true;
  2601.             int hourOffset;
  2602.             int minuteOffset = 0;
  2603.            
  2604.             switch (len) {
  2605.                 case 1:
  2606.                 case 2:
  2607.                     if (!ParseSign(ref str, ref isPositive)) {
  2608.                         return (false);
  2609.                     }
  2610.                     if (!ParseDigits(ref str, len, out hourOffset)) {
  2611.                         return (false);
  2612.                     }
  2613.                     break;
  2614.                 default:
  2615.                     if (!ParseSign(ref str, ref isPositive)) {
  2616.                         return (false);
  2617.                     }
  2618.                    
  2619.                     // Parsing 1 digit will actually parse 1 or 2.
  2620.                     if (!ParseDigits(ref str, 1, out hourOffset)) {
  2621.                         return (false);
  2622.                     }
  2623.                     // ':' is optional.
  2624.                     if (str.Match(":")) {
  2625.                         // Found ':'
  2626.                         if (!ParseDigits(ref str, 2, out minuteOffset)) {
  2627.                             return (false);
  2628.                         }
  2629.                     }
  2630.                     else {
  2631.                         // Since we can not match ':', put the char back.
  2632.                         str.Index--;
  2633.                         if (!ParseDigits(ref str, 2, out minuteOffset)) {
  2634.                             return (false);
  2635.                         }
  2636.                     }
  2637.                     break;
  2638.             }
  2639.             if (minuteOffset < 0 || minuteOffset >= 60) {
  2640.                 return false;
  2641.             }
  2642.             result = (new TimeSpan(hourOffset, minuteOffset, 0));
  2643.             if (!isPositive) {
  2644.                 result = result.Negate();
  2645.             }
  2646.             return (true);
  2647.         }
  2648.        
  2649. /*=================================MatchAbbreviatedMonthName==================================
  2650.         **Action: Parse the abbreviated month name from string starting at str.Index.
  2651.         **Returns: A value from 1 to 12 for the first month to the twelveth month.
  2652.         **Arguments:    str: a __DTString.  The parsing will start from the
  2653.         **              next character after str.Index.
  2654.         **Exceptions: FormatException if an abbreviated month name can not be found.
  2655.         ==============================================================================*/       
  2656.        
  2657.         private static bool MatchAbbreviatedMonthName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
  2658.         {
  2659.             int maxMatchStrLen = 0;
  2660.             result = -1;
  2661.             if (str.GetNext()) {
  2662.                 //
  2663.                 // Scan the month names (note that some calendars has 13 months) and find
  2664.                 // the matching month name which has the max string length.
  2665.                 // We need to do this because some cultures (e.g. "cs-CZ") which have
  2666.                 // abbreviated month names with the same prefix.
  2667.                 //
  2668.                 int monthsInYear = (dtfi.GetMonthName(13).Length == 0 ? 12 : 13);
  2669.                 for (int i = 1; i <= monthsInYear; i++) {
  2670.                     string searchStr = dtfi.GetAbbreviatedMonthName(i);
  2671.                     int matchStrLen = searchStr.Length;
  2672.                     if (dtfi.HasSpacesInMonthNames ? str.MatchSpecifiedWords(searchStr, false, ref matchStrLen) : str.MatchSpecifiedWord(searchStr)) {
  2673.                         if (matchStrLen > maxMatchStrLen) {
  2674.                             maxMatchStrLen = matchStrLen;
  2675.                             result = i;
  2676.                         }
  2677.                     }
  2678.                 }
  2679.                
  2680.                 // Search leap year form.
  2681.                 if ((dtfi.FormatFlags & DateTimeFormatFlags.UseLeapYearMonth) != 0) {
  2682.                     int tempResult = str.MatchLongestWords(dtfi.internalGetLeapYearMonthNames(), ref maxMatchStrLen);
  2683.                     // We found a longer match in the leap year month name. Use this as the result.
  2684.                     // The result from MatchLongestWords is 0 ~ length of word array.
  2685.                     // So we increment the result by one to become the month value.
  2686.                     if (tempResult >= 0) {
  2687.                         result = tempResult + 1;
  2688.                     }
  2689.                 }
  2690.                
  2691.                
  2692.             }
  2693.             if (result > 0) {
  2694.                 str.Index += (maxMatchStrLen - 1);
  2695.                 return (true);
  2696.             }
  2697.             return false;
  2698.         }
  2699.        
  2700. /*=================================MatchMonthName==================================
  2701.         **Action: Parse the month name from string starting at str.Index.
  2702.         **Returns: A value from 1 to 12 indicating the first month to the twelveth month.
  2703.         **Arguments:    str: a __DTString.  The parsing will start from the
  2704.         **              next character after str.Index.
  2705.         **Exceptions: FormatException if a month name can not be found.
  2706.         ==============================================================================*/       
  2707.        
  2708.         private static bool MatchMonthName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
  2709.         {
  2710.             int maxMatchStrLen = 0;
  2711.             result = -1;
  2712.             if (str.GetNext()) {
  2713.                 //
  2714.                 // Scan the month names (note that some calendars has 13 months) and find
  2715.                 // the matching month name which has the max string length.
  2716.                 // We need to do this because some cultures (e.g. "vi-VN") which have
  2717.                 // month names with the same prefix.
  2718.                 //
  2719.                 int monthsInYear = (dtfi.GetMonthName(13).Length == 0 ? 12 : 13);
  2720.                 for (int i = 1; i <= monthsInYear; i++) {
  2721.                     string searchStr = dtfi.GetMonthName(i);
  2722.                     int matchStrLen = searchStr.Length;
  2723.                     if (dtfi.HasSpacesInMonthNames ? str.MatchSpecifiedWords(searchStr, false, ref matchStrLen) : str.MatchSpecifiedWord(searchStr)) {
  2724.                         if (matchStrLen > maxMatchStrLen) {
  2725.                             maxMatchStrLen = matchStrLen;
  2726.                             result = i;
  2727.                         }
  2728.                     }
  2729.                 }
  2730.                
  2731.                 // Search genitive form.
  2732.                 if ((dtfi.FormatFlags & DateTimeFormatFlags.UseGenitiveMonth) != 0) {
  2733.                     int tempResult = str.MatchLongestWords(dtfi.MonthGenitiveNames, ref maxMatchStrLen);
  2734.                     // We found a longer match in the genitive month name. Use this as the result.
  2735.                     // The result from MatchLongestWords is 0 ~ length of word array.
  2736.                     // So we increment the result by one to become the month value.
  2737.                     if (tempResult >= 0) {
  2738.                         result = tempResult + 1;
  2739.                     }
  2740.                 }
  2741.                
  2742.                 // Search leap year form.
  2743.                 if ((dtfi.FormatFlags & DateTimeFormatFlags.UseLeapYearMonth) != 0) {
  2744.                     int tempResult = str.MatchLongestWords(dtfi.internalGetLeapYearMonthNames(), ref maxMatchStrLen);
  2745.                     // We found a longer match in the leap year month name. Use this as the result.
  2746.                     // The result from MatchLongestWords is 0 ~ length of word array.
  2747.                     // So we increment the result by one to become the month value.
  2748.                     if (tempResult >= 0) {
  2749.                         result = tempResult + 1;
  2750.                     }
  2751.                 }
  2752.                
  2753.                
  2754.             }
  2755.            
  2756.             if (result > 0) {
  2757.                 str.Index += (maxMatchStrLen - 1);
  2758.                 return (true);
  2759.             }
  2760.             return false;
  2761.         }
  2762.        
  2763. /*=================================MatchAbbreviatedDayName==================================
  2764.         **Action: Parse the abbreviated day of week name from string starting at str.Index.
  2765.         **Returns: A value from 0 to 6 indicating Sunday to Saturday.
  2766.         **Arguments:    str: a __DTString.  The parsing will start from the
  2767.         **              next character after str.Index.
  2768.         **Exceptions: FormatException if a abbreviated day of week name can not be found.
  2769.         ==============================================================================*/       
  2770.        
  2771.         private static bool MatchAbbreviatedDayName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
  2772.         {
  2773.             int maxMatchStrLen = 0;
  2774.             result = -1;
  2775.             if (str.GetNext()) {
  2776.                 for (DayOfWeek i = DayOfWeek.Sunday; i <= DayOfWeek.Saturday; i++) {
  2777.                     string searchStr = dtfi.GetAbbreviatedDayName(i);
  2778.                     int matchStrLen = searchStr.Length;
  2779.                     if (dtfi.HasSpacesInDayNames ? str.MatchSpecifiedWords(searchStr, false, ref matchStrLen) : str.MatchSpecifiedWord(searchStr)) {
  2780.                         if (matchStrLen > maxMatchStrLen) {
  2781.                             maxMatchStrLen = matchStrLen;
  2782.                             result = (int)i;
  2783.                         }
  2784.                     }
  2785.                 }
  2786.             }
  2787.             if (result >= 0) {
  2788.                 str.Index += maxMatchStrLen - 1;
  2789.                 return (true);
  2790.             }
  2791.             return false;
  2792.         }
  2793.        
  2794. /*=================================MatchDayName==================================
  2795.         **Action: Parse the day of week name from string starting at str.Index.
  2796.         **Returns: A value from 0 to 6 indicating Sunday to Saturday.
  2797.         **Arguments:    str: a __DTString.  The parsing will start from the
  2798.         **              next character after str.Index.
  2799.         **Exceptions: FormatException if a day of week name can not be found.
  2800.         ==============================================================================*/       
  2801.        
  2802.         private static bool MatchDayName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
  2803.         {
  2804.             // Turkish (tr-TR) got day names with the same prefix.
  2805.             int maxMatchStrLen = 0;
  2806.             result = -1;
  2807.             if (str.GetNext()) {
  2808.                 for (DayOfWeek i = DayOfWeek.Sunday; i <= DayOfWeek.Saturday; i++) {
  2809.                     string searchStr = dtfi.GetDayName(i);
  2810.                     int matchStrLen = searchStr.Length;
  2811.                     if (dtfi.HasSpacesInDayNames ? str.MatchSpecifiedWords(searchStr, false, ref matchStrLen) : str.MatchSpecifiedWord(searchStr)) {
  2812.                         if (matchStrLen > maxMatchStrLen) {
  2813.                             maxMatchStrLen = matchStrLen;
  2814.                             result = (int)i;
  2815.                         }
  2816.                     }
  2817.                 }
  2818.             }
  2819.             if (result >= 0) {
  2820.                 str.Index += maxMatchStrLen - 1;
  2821.                 return (true);
  2822.             }
  2823.             return false;
  2824.         }
  2825.        
  2826. /*=================================MatchEraName==================================
  2827.         **Action: Parse era name from string starting at str.Index.
  2828.         **Returns: An era value.
  2829.         **Arguments:    str: a __DTString.  The parsing will start from the
  2830.         **              next character after str.Index.
  2831.         **Exceptions: FormatException if an era name can not be found.
  2832.         ==============================================================================*/       
  2833.        
  2834.         private static bool MatchEraName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
  2835.         {
  2836.             if (str.GetNext()) {
  2837.                 int[] eras = dtfi.Calendar.Eras;
  2838.                
  2839.                 if (eras != null) {
  2840.                     for (int i = 0; i < eras.Length; i++) {
  2841.                         string searchStr = dtfi.GetEraName(eras[i]);
  2842.                         if (str.MatchSpecifiedWord(searchStr)) {
  2843.                             str.Index += (searchStr.Length - 1);
  2844.                             result = eras[i];
  2845.                             return (true);
  2846.                         }
  2847.                         searchStr = dtfi.GetAbbreviatedEraName(eras[i]);
  2848.                         if (str.MatchSpecifiedWord(searchStr)) {
  2849.                             str.Index += (searchStr.Length - 1);
  2850.                             result = eras[i];
  2851.                             return (true);
  2852.                         }
  2853.                     }
  2854.                 }
  2855.             }
  2856.             return false;
  2857.         }
  2858.        
  2859. /*=================================MatchTimeMark==================================
  2860.         **Action: Parse the time mark (AM/PM) from string starting at str.Index.
  2861.         **Returns: TM_AM or TM_PM.
  2862.         **Arguments:    str: a __DTString.  The parsing will start from the
  2863.         **              next character after str.Index.
  2864.         **Exceptions: FormatException if a time mark can not be found.
  2865.         ==============================================================================*/       
  2866.        
  2867.         private static bool MatchTimeMark(ref __DTString str, DateTimeFormatInfo dtfi, ref TM result)
  2868.         {
  2869.             result = TM.NotSet;
  2870.             // In some cultures have empty strings in AM/PM mark. E.g. af-ZA (0x0436), the AM mark is "", and PM mark is "nm".
  2871.             if (dtfi.AMDesignator.Length == 0) {
  2872.                 result = TM.AM;
  2873.             }
  2874.             if (dtfi.PMDesignator.Length == 0) {
  2875.                 result = TM.PM;
  2876.             }
  2877.            
  2878.             if (str.GetNext()) {
  2879.                 string searchStr = dtfi.AMDesignator;
  2880.                 if (searchStr.Length > 0) {
  2881.                     if (str.MatchSpecifiedWord(searchStr)) {
  2882.                         // Found an AM timemark with length > 0.
  2883.                         str.Index += (searchStr.Length - 1);
  2884.                         result = TM.AM;
  2885.                         return (true);
  2886.                     }
  2887.                 }
  2888.                 searchStr = dtfi.PMDesignator;
  2889.                 if (searchStr.Length > 0) {
  2890.                     if (str.MatchSpecifiedWord(searchStr)) {
  2891.                         // Found a PM timemark with length > 0.
  2892.                         str.Index += (searchStr.Length - 1);
  2893.                         result = TM.PM;
  2894.                         return (true);
  2895.                     }
  2896.                 }
  2897.                 str.Index--;
  2898.                 // Undo the GetNext call.
  2899.             }
  2900.             if (result != TM.NotSet) {
  2901.                 // If one of the AM/PM marks is empty string, return the result.
  2902.                 return (true);
  2903.             }
  2904.             return false;
  2905.         }
  2906.        
  2907. /*=================================MatchAbbreviatedTimeMark==================================
  2908.         **Action: Parse the abbreviated time mark (AM/PM) from string starting at str.Index.
  2909.         **Returns: TM_AM or TM_PM.
  2910.         **Arguments:    str: a __DTString.  The parsing will start from the
  2911.         **              next character after str.Index.
  2912.         **Exceptions: FormatException if a abbreviated time mark can not be found.
  2913.         ==============================================================================*/       
  2914.        
  2915.         private static bool MatchAbbreviatedTimeMark(ref __DTString str, DateTimeFormatInfo dtfi, ref TM result)
  2916.         {
  2917.             if (str.GetNext()) {
  2918.                 if (str.GetChar() == dtfi.AMDesignator[0]) {
  2919.                     result = TM.AM;
  2920.                     return (true);
  2921.                 }
  2922.                 if (str.GetChar() == dtfi.PMDesignator[0]) {
  2923.                     result = TM.PM;
  2924.                     return (true);
  2925.                 }
  2926.             }
  2927.             return false;
  2928.         }
  2929.        
  2930. /*=================================CheckNewValue==================================
  2931.         **Action: Check if currentValue is initialized.  If not, return the newValue.
  2932.         **        If yes, check if the current value is equal to newValue.  Return false
  2933.         **        if they are not equal.  This is used to check the case like "d" and "dd" are both
  2934.         **        used to format a string.
  2935.         **Returns: the correct value for currentValue.
  2936.         **Arguments:
  2937.         **Exceptions:
  2938.         ==============================================================================*/       
  2939.        
  2940.         private static bool CheckNewValue(ref int currentValue, int newValue, char patternChar, ref DateTimeResult result)
  2941.         {
  2942.             if (currentValue == -1) {
  2943.                 currentValue = newValue;
  2944.                 return (true);
  2945.             }
  2946.             else {
  2947.                 if (newValue != currentValue) {
  2948.                     result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", patternChar);
  2949.                     return (false);
  2950.                 }
  2951.             }
  2952.             return (true);
  2953.         }
  2954.        
  2955.         private static void CheckDefaultDateTime(ref DateTimeResult result, ref Calendar cal, DateTimeStyles styles)
  2956.         {
  2957.            
  2958.             if ((result.Year == -1) || (result.Month == -1) || (result.Day == -1)) {
  2959.                 /*
  2960.                 The following table describes the behaviors of getting the default value
  2961.                 when a certain year/month/day values are missing.
  2962.                 An "X" means that the value exists.  And "--" means that value is missing.
  2963.                 Year    Month  Day =>  ResultYear  ResultMonth    ResultDay      Note
  2964.                 X      X      X      Parsed year Parsed month    Parsed day
  2965.                 X      X      --      Parsed Year Parsed month    First day      If we have year and month, assume the first day of that month.
  2966.                 X      --      X      Parsed year First month    Parsed day      If the month is missing, assume first month of that year.
  2967.                 X      --      --      Parsed year First month    First day      If we have only the year, assume the first day of that year.
  2968.                 --      X      X      CurrentYear Parsed month    Parsed day      If the year is missing, assume the current year.
  2969.                 --      X      --      CurrentYear Parsed month    First day      If we have only a month value, assume the current year and current day.
  2970.                 --      --      X      CurrentYear First month    Parsed day      If we have only a day value, assume current year and first month.
  2971.                 --      --      --      CurrentYear Current month  Current day    So this means that if the date string only contains time, you will get current date.
  2972.                 */               
  2973.                
  2974. DateTime now = DateTime.Now;
  2975.                 if (result.Month == -1 && result.Day == -1) {
  2976.                     if (result.Year == -1) {
  2977.                         if ((styles & DateTimeStyles.NoCurrentDateDefault) != 0) {
  2978.                             // If there is no year/month/day values, and NoCurrentDateDefault flag is used,
  2979.                             // set the year/month/day value to the beginning year/month/day of DateTime().
  2980.                             // Note we should be using Gregorian for the year/month/day.
  2981.                             cal = GregorianCalendar.GetDefaultInstance();
  2982.                             result.Year = result.Month = result.Day = 1;
  2983.                         }
  2984.                         else {
  2985.                             // Year/Month/Day are all missing.
  2986.                             result.Year = cal.GetYear(now);
  2987.                             result.Month = cal.GetMonth(now);
  2988.                             result.Day = cal.GetDayOfMonth(now);
  2989.                         }
  2990.                     }
  2991.                     else {
  2992.                         // Month/Day are both missing.
  2993.                         result.Month = 1;
  2994.                         result.Day = 1;
  2995.                     }
  2996.                 }
  2997.                 else {
  2998.                     if (result.Year == -1) {
  2999.                         result.Year = cal.GetYear(now);
  3000.                     }
  3001.                     if (result.Month == -1) {
  3002.                         result.Month = 1;
  3003.                     }
  3004.                     if (result.Day == -1) {
  3005.                         result.Day = 1;
  3006.                     }
  3007.                 }
  3008.             }
  3009.             // Set Hour/Minute/Second to zero if these value are not in str.
  3010.             if (result.Hour == -1)
  3011.                 result.Hour = 0;
  3012.             if (result.Minute == -1)
  3013.                 result.Minute = 0;
  3014.             if (result.Second == -1)
  3015.                 result.Second = 0;
  3016.             if (result.era == -1)
  3017.                 result.era = Calendar.CurrentEra;
  3018.         }
  3019.        
  3020.         // Expand a pre-defined format string (like "D" for long date) to the real format that
  3021.         // we are going to use in the date time parsing.
  3022.         // This method also set the dtfi according/parseInfo to some special pre-defined
  3023.         // formats.
  3024.         //
  3025.         private static string ExpandPredefinedFormat(string format, ref DateTimeFormatInfo dtfi, ref ParsingInfo parseInfo, ref DateTimeResult result)
  3026.         {
  3027.             //
  3028.             // Check the format to see if we need to override the dtfi to be InvariantInfo,
  3029.             // and see if we need to set up the userUniversalTime flag.
  3030.             //
  3031.             switch (format[0]) {
  3032.                 case 'o':
  3033.                 case 'O':
  3034.                     // Round Trip Format
  3035.                     parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
  3036.                     dtfi = DateTimeFormatInfo.InvariantInfo;
  3037.                     break;
  3038.                 case 'r':
  3039.                 case 'R':
  3040.                     // RFC 1123 Standard. (in Universal time)
  3041.                     parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
  3042.                     dtfi = DateTimeFormatInfo.InvariantInfo;
  3043.                     break;
  3044.                 case 's':
  3045.                     // Sortable format (in local time)
  3046.                     dtfi = DateTimeFormatInfo.InvariantInfo;
  3047.                     parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
  3048.                     break;
  3049.                 case 'u':
  3050.                     // Universal time format in sortable format.
  3051.                     parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
  3052.                     dtfi = DateTimeFormatInfo.InvariantInfo;
  3053.                     break;
  3054.                 case 'U':
  3055.                     // Universal time format with culture-dependent format.
  3056.                     parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
  3057.                     result.flags |= ParseFlags.TimeZoneUsed;
  3058.                     result.timeZoneOffset = new TimeSpan(0);
  3059.                     result.flags |= ParseFlags.TimeZoneUtc;
  3060.                     if (dtfi.Calendar.GetType() != typeof(GregorianCalendar)) {
  3061.                         dtfi = (DateTimeFormatInfo)dtfi.Clone();
  3062.                         dtfi.Calendar = GregorianCalendar.GetDefaultInstance();
  3063.                     }
  3064.                     break;
  3065.             }
  3066.            
  3067.             //
  3068.             // Expand the pre-defined format character to the real format from DateTimeFormatInfo.
  3069.             //
  3070.             return (DateTimeFormat.GetRealFormat(format, dtfi));
  3071.         }
  3072.        
  3073.         // Given a specified format character, parse and update the parsing result.
  3074.         //
  3075.         private static bool ParseByFormat(ref __DTString str, ref __DTString format, ref ParsingInfo parseInfo, DateTimeFormatInfo dtfi, ref DateTimeResult result)
  3076.         {
  3077.            
  3078.             int tokenLen = 0;
  3079.             int tempYear = 0;
  3080.             int tempMonth = 0;
  3081.             int tempDay = 0;
  3082.             int tempDayOfWeek = 0;
  3083.             int tempHour = 0;
  3084.             int tempMinute = 0;
  3085.             int tempSecond = 0;
  3086.             double tempFraction = 0;
  3087.             TM tempTimeMark = 0;
  3088.            
  3089.             char ch = format.GetChar();
  3090.            
  3091.             switch (ch) {
  3092.                 case 'y':
  3093.                     tokenLen = format.GetRepeatCount();
  3094.                     bool parseResult;
  3095.                     if (dtfi.HasForceTwoDigitYears) {
  3096.                         parseResult = ParseDigits(ref str, 1, 4, out tempYear);
  3097.                     }
  3098.                     else {
  3099.                         if (tokenLen <= 2) {
  3100.                             parseInfo.fUseTwoDigitYear = true;
  3101.                         }
  3102.                         parseResult = ParseDigits(ref str, tokenLen, out tempYear);
  3103.                     }
  3104.                     if (!parseResult && parseInfo.fCustomNumberParser) {
  3105.                         parseResult = parseInfo.parseNumberDelegate(ref str, tokenLen, out tempYear);
  3106.                     }
  3107.                     if (!parseResult) {
  3108.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3109.                         return (false);
  3110.                     }
  3111.                     if (!CheckNewValue(ref result.Year, tempYear, ch, ref result)) {
  3112.                         return (false);
  3113.                     }
  3114.                     break;
  3115.                 case 'M':
  3116.                     tokenLen = format.GetRepeatCount();
  3117.                     if (tokenLen <= 2) {
  3118.                         if (!ParseDigits(ref str, tokenLen, out tempMonth)) {
  3119.                             if (!parseInfo.fCustomNumberParser || !parseInfo.parseNumberDelegate(ref str, tokenLen, out tempMonth)) {
  3120.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3121.                                 return (false);
  3122.                             }
  3123.                         }
  3124.                     }
  3125.                     else {
  3126.                         if (tokenLen == 3) {
  3127.                             if (!MatchAbbreviatedMonthName(ref str, dtfi, ref tempMonth)) {
  3128.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3129.                                 return (false);
  3130.                             }
  3131.                         }
  3132.                         else {
  3133.                             if (!MatchMonthName(ref str, dtfi, ref tempMonth)) {
  3134.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3135.                                 return (false);
  3136.                             }
  3137.                         }
  3138.                         result.flags |= ParseFlags.ParsedMonthName;
  3139.                     }
  3140.                     if (!CheckNewValue(ref result.Month, tempMonth, ch, ref result)) {
  3141.                         return (false);
  3142.                     }
  3143.                     break;
  3144.                 case 'd':
  3145.                     // Day & Day of week
  3146.                     tokenLen = format.GetRepeatCount();
  3147.                     if (tokenLen <= 2) {
  3148.                         // "d" & "dd"
  3149.                        
  3150.                         if (!ParseDigits(ref str, tokenLen, out tempDay)) {
  3151.                             if (!parseInfo.fCustomNumberParser || !parseInfo.parseNumberDelegate(ref str, tokenLen, out tempDay)) {
  3152.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3153.                                 return (false);
  3154.                             }
  3155.                         }
  3156.                         if (!CheckNewValue(ref result.Day, tempDay, ch, ref result)) {
  3157.                             return (false);
  3158.                         }
  3159.                     }
  3160.                     else {
  3161.                         if (tokenLen == 3) {
  3162.                             // "ddd"
  3163.                             if (!MatchAbbreviatedDayName(ref str, dtfi, ref tempDayOfWeek)) {
  3164.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3165.                                 return (false);
  3166.                             }
  3167.                         }
  3168.                         else {
  3169.                             // "dddd*"
  3170.                             if (!MatchDayName(ref str, dtfi, ref tempDayOfWeek)) {
  3171.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3172.                                 return (false);
  3173.                             }
  3174.                         }
  3175.                         if (!CheckNewValue(ref parseInfo.dayOfWeek, tempDayOfWeek, ch, ref result)) {
  3176.                             return (false);
  3177.                         }
  3178.                     }
  3179.                     break;
  3180.                 case 'g':
  3181.                     tokenLen = format.GetRepeatCount();
  3182.                     // Put the era value in result.era.
  3183.                     if (!MatchEraName(ref str, dtfi, ref result.era)) {
  3184.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3185.                         return (false);
  3186.                     }
  3187.                     break;
  3188.                 case 'h':
  3189.                     parseInfo.fUseHour12 = true;
  3190.                     tokenLen = format.GetRepeatCount();
  3191.                     if (!ParseDigits(ref str, (tokenLen < 2 ? 1 : 2), out tempHour)) {
  3192.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3193.                         return (false);
  3194.                     }
  3195.                     if (!CheckNewValue(ref result.Hour, tempHour, ch, ref result)) {
  3196.                         return (false);
  3197.                     }
  3198.                     break;
  3199.                 case 'H':
  3200.                     tokenLen = format.GetRepeatCount();
  3201.                     if (!ParseDigits(ref str, (tokenLen < 2 ? 1 : 2), out tempHour)) {
  3202.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3203.                         return (false);
  3204.                     }
  3205.                     if (!CheckNewValue(ref result.Hour, tempHour, ch, ref result)) {
  3206.                         return (false);
  3207.                     }
  3208.                     break;
  3209.                 case 'm':
  3210.                     tokenLen = format.GetRepeatCount();
  3211.                     if (!ParseDigits(ref str, (tokenLen < 2 ? 1 : 2), out tempMinute)) {
  3212.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3213.                         return (false);
  3214.                     }
  3215.                     if (!CheckNewValue(ref result.Minute, tempMinute, ch, ref result)) {
  3216.                         return (false);
  3217.                     }
  3218.                     break;
  3219.                 case 's':
  3220.                     tokenLen = format.GetRepeatCount();
  3221.                     if (!ParseDigits(ref str, (tokenLen < 2 ? 1 : 2), out tempSecond)) {
  3222.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3223.                         return (false);
  3224.                     }
  3225.                     if (!CheckNewValue(ref result.Second, tempSecond, ch, ref result)) {
  3226.                         return (false);
  3227.                     }
  3228.                     break;
  3229.                 case 'f':
  3230.                 case 'F':
  3231.                     tokenLen = format.GetRepeatCount();
  3232.                     if (tokenLen <= DateTimeFormat.MaxSecondsFractionDigits) {
  3233.                         if (!ParseFractionExact(ref str, tokenLen, ref tempFraction)) {
  3234.                             if (ch == 'f') {
  3235.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3236.                                 return (false);
  3237.                             }
  3238.                         }
  3239.                         if (result.fraction < 0) {
  3240.                             result.fraction = tempFraction;
  3241.                         }
  3242.                         else {
  3243.                             if (tempFraction != result.fraction) {
  3244.                                 result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", ch);
  3245.                                 return (false);
  3246.                             }
  3247.                         }
  3248.                     }
  3249.                     else {
  3250.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3251.                         return (false);
  3252.                     }
  3253.                     break;
  3254.                 case 't':
  3255.                     // AM/PM designator
  3256.                     tokenLen = format.GetRepeatCount();
  3257.                     if (tokenLen == 1) {
  3258.                         if (!MatchAbbreviatedTimeMark(ref str, dtfi, ref tempTimeMark)) {
  3259.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3260.                             return (false);
  3261.                         }
  3262.                     }
  3263.                     else {
  3264.                         if (!MatchTimeMark(ref str, dtfi, ref tempTimeMark)) {
  3265.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3266.                             return (false);
  3267.                         }
  3268.                     }
  3269.                    
  3270.                     if (parseInfo.timeMark == TM.NotSet) {
  3271.                         parseInfo.timeMark = tempTimeMark;
  3272.                     }
  3273.                     else {
  3274.                         if (parseInfo.timeMark != tempTimeMark) {
  3275.                             result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", ch);
  3276.                             return (false);
  3277.                         }
  3278.                     }
  3279.                     break;
  3280.                 case 'z':
  3281.                     // timezone offset
  3282.                     tokenLen = format.GetRepeatCount();
  3283.                    
  3284.                     {
  3285.                         TimeSpan tempTimeZoneOffset = new TimeSpan(0);
  3286.                         if (!ParseTimeZoneOffset(ref str, tokenLen, ref tempTimeZoneOffset)) {
  3287.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3288.                             return (false);
  3289.                         }
  3290.                         if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && tempTimeZoneOffset != result.timeZoneOffset) {
  3291.                             result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'z');
  3292.                             return (false);
  3293.                         }
  3294.                         result.timeZoneOffset = tempTimeZoneOffset;
  3295.                         result.flags |= ParseFlags.TimeZoneUsed;
  3296.                     }
  3297.                     break;
  3298.                 case 'Z':
  3299.                     if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result.timeZoneOffset != TimeSpan.Zero) {
  3300.                         result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'Z');
  3301.                         return (false);
  3302.                     }
  3303.                     result.flags |= ParseFlags.TimeZoneUsed;
  3304.                     result.timeZoneOffset = new TimeSpan(0);
  3305.                     result.flags |= ParseFlags.TimeZoneUtc;
  3306.                    
  3307.                     // The updating of the indexes is to reflect that ParseExact MatchXXX methods assume that
  3308.                     // they need to increment the index and Parse GetXXX do not. Since we are calling a Parse
  3309.                     // method from inside ParseExact we need to adjust this. Long term, we should try to
  3310.                     // eliminate this discrepancy.
  3311.                     str.Index++;
  3312.                     if (!GetTimeZoneName(ref str)) {
  3313.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3314.                         return false;
  3315.                     }
  3316.                     str.Index--;
  3317.                     break;
  3318.                 case 'K':
  3319.                     // This should parse either as a blank, the 'Z' character or a local offset like "-07:00"
  3320.                     if (str.Match('Z')) {
  3321.                         if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result.timeZoneOffset != TimeSpan.Zero) {
  3322.                             result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'K');
  3323.                             return (false);
  3324.                         }
  3325.                         result.flags |= ParseFlags.TimeZoneUsed;
  3326.                         result.timeZoneOffset = new TimeSpan(0);
  3327.                         result.flags |= ParseFlags.TimeZoneUtc;
  3328.                     }
  3329.                     else if (str.Match('+') || str.Match('-')) {
  3330.                         str.Index--;
  3331.                         // Put the character back for the parser
  3332.                         TimeSpan tempTimeZoneOffset = new TimeSpan(0);
  3333.                         if (!ParseTimeZoneOffset(ref str, 3, ref tempTimeZoneOffset)) {
  3334.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3335.                             return (false);
  3336.                         }
  3337.                         if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && tempTimeZoneOffset != result.timeZoneOffset) {
  3338.                             result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'K');
  3339.                             return (false);
  3340.                         }
  3341.                         result.timeZoneOffset = tempTimeZoneOffset;
  3342.                         result.flags |= ParseFlags.TimeZoneUsed;
  3343.                     }
  3344.                     // Otherwise it is unspecified and we consume no characters
  3345.                     break;
  3346.                 case ':':
  3347.                     if (!str.Match(dtfi.TimeSeparator)) {
  3348.                         // A time separator is expected.
  3349.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3350.                         return false;
  3351.                     }
  3352.                     break;
  3353.                 case '/':
  3354.                     if (!str.Match(dtfi.DateSeparator)) {
  3355.                         // A date separator is expected.
  3356.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3357.                         return false;
  3358.                     }
  3359.                     break;
  3360.                 case '"':
  3361.                 case '\'':
  3362.                     StringBuilder enquotedString = new StringBuilder();
  3363.                     // Use ParseQuoteString so that we can handle escape characters within the quoted string.
  3364.                     if (!TryParseQuoteString(format.Value, format.Index, enquotedString, out tokenLen)) {
  3365.                         result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadQuote", ch);
  3366.                         return (false);
  3367.                     }
  3368.                     format.Index += tokenLen - 1;
  3369.                    
  3370.                     // Some cultures uses space in the quoted string. E.g. Spanish has long date format as:
  3371.                     // "dddd, dd' de 'MMMM' de 'yyyy". When inner spaces flag is set, we should skip whitespaces if there is space
  3372.                     // in the quoted string.
  3373.                     string quotedStr = enquotedString.ToString();
  3374.                     for (int i = 0; i < quotedStr.Length; i++) {
  3375.                         if (quotedStr[i] == ' ' && parseInfo.fAllowInnerWhite) {
  3376.                             str.SkipWhiteSpaces();
  3377.                         }
  3378.                         else if (!str.Match(quotedStr[i])) {
  3379.                             // Can not find the matching quoted string.
  3380.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3381.                             return false;
  3382.                         }
  3383.                     }
  3384.                     break;
  3385.                 case '%':
  3386.                     // Skip this so we can get to the next pattern character.
  3387.                     // Used in case like "%d", "%y"
  3388.                    
  3389.                     // Make sure the next character is not a '%' again.
  3390.                     if (format.Index >= format.Value.Length - 1 || format.Value[format.Index + 1] == '%') {
  3391.                         result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
  3392.                         return false;
  3393.                     }
  3394.                     break;
  3395.                 case '\\':
  3396.                     // Escape character. For example, "\d".
  3397.                     // Get the next character in format, and see if we can
  3398.                     // find a match in str.
  3399.                     if (format.GetNext()) {
  3400.                         if (!str.Match(format.GetChar())) {
  3401.                             // Can not find a match for the escaped character.
  3402.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3403.                             return false;
  3404.                         }
  3405.                     }
  3406.                     else {
  3407.                         result.SetFailure(ParseFailureKind.Format, "Format_BadFormatSpecifier", null);
  3408.                         return false;
  3409.                     }
  3410.                     break;
  3411.                 case '.':
  3412.                     if (!str.Match(ch)) {
  3413.                         if (format.GetNext()) {
  3414.                             // If we encounter the pattern ".F", and the dot is not present, it is an optional
  3415.                             // second fraction and we can skip this format.
  3416.                             if (format.Match('F')) {
  3417.                                 format.GetRepeatCount();
  3418.                                 break;
  3419.                             }
  3420.                         }
  3421.                         result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3422.                         return false;
  3423.                     }
  3424.                     break;
  3425.                 default:
  3426.                     if (ch == ' ') {
  3427.                         if (parseInfo.fAllowInnerWhite) {
  3428.                             // Skip whitespaces if AllowInnerWhite.
  3429.                             // Do nothing here.
  3430.                         }
  3431.                         else {
  3432.                             if (!str.Match(ch)) {
  3433.                                 // If the space does not match, and trailing space is allowed, we do
  3434.                                 // one more step to see if the next format character can lead to
  3435.                                 // successful parsing.
  3436.                                 // This is used to deal with special case that a empty string can match
  3437.                                 // a specific pattern.
  3438.                                 // The example here is af-ZA, which has a time format like "hh:mm:ss tt". However,
  3439.                                 // its AM symbol is "" (empty string). If fAllowTrailingWhite is used, and time is in
  3440.                                 // the AM, we will trim the whitespaces at the end, which will lead to a failure
  3441.                                 // when we are trying to match the space before "tt".
  3442.                                 if (parseInfo.fAllowTrailingWhite) {
  3443.                                     if (format.GetNext()) {
  3444.                                         if (ParseByFormat(ref str, ref format, ref parseInfo, dtfi, ref result)) {
  3445.                                             return (true);
  3446.                                         }
  3447.                                     }
  3448.                                 }
  3449.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3450.                                 return false;
  3451.                             }
  3452.                             // Found a macth.
  3453.                         }
  3454.                     }
  3455.                     else {
  3456.                         if (format.MatchSpecifiedWord(GMTName)) {
  3457.                             format.Index += (GMTName.Length - 1);
  3458.                             // Found GMT string in format. This means the DateTime string
  3459.                             // is in GMT timezone.
  3460.                             result.flags |= ParseFlags.TimeZoneUsed;
  3461.                             result.timeZoneOffset = TimeSpan.Zero;
  3462.                             if (!str.Match(GMTName)) {
  3463.                                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3464.                                 return false;
  3465.                             }
  3466.                         }
  3467.                         else if (!str.Match(ch)) {
  3468.                             // ch is expected.
  3469.                             result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3470.                             return false;
  3471.                         }
  3472.                     }
  3473.                     break;
  3474.             }
  3475.             // switch
  3476.             return (true);
  3477.         }
  3478.        
  3479.         //
  3480.         // The pos should point to a quote character. This method will
  3481.         // get the string encloed by the quote character.
  3482.         //
  3483.         static internal bool TryParseQuoteString(string format, int pos, StringBuilder result, out int returnValue)
  3484.         {
  3485.             //
  3486.             // NOTE : pos will be the index of the quote character in the 'format' string.
  3487.             //
  3488.             returnValue = 0;
  3489.             int formatLen = format.Length;
  3490.             int beginPos = pos;
  3491.             char quoteChar = format[pos++];
  3492.             // Get the character used to quote the following string.
  3493.             bool foundQuote = false;
  3494.             while (pos < formatLen) {
  3495.                 char ch = format[pos++];
  3496.                 if (ch == quoteChar) {
  3497.                     foundQuote = true;
  3498.                     break;
  3499.                 }
  3500.                 else if (ch == '\\') {
  3501.                     // The following are used to support escaped character.
  3502.                     // Escaped character is also supported in the quoted string.
  3503.                     // Therefore, someone can use a format like "'minute:' mm\"" to display:
  3504.                     // minute: 45"
  3505.                     // because the second double quote is escaped.
  3506.                     if (pos < formatLen) {
  3507.                         result.Append(format[pos++]);
  3508.                     }
  3509.                     else {
  3510.                         //
  3511.                         // This means that '\' is at the end of the formatting string.
  3512.                         //
  3513.                         return false;
  3514.                     }
  3515.                 }
  3516.                 else {
  3517.                     result.Append(ch);
  3518.                 }
  3519.             }
  3520.            
  3521.             if (!foundQuote) {
  3522.                 // Here we can't find the matching quote.
  3523.                 return false;
  3524.             }
  3525.            
  3526.             //
  3527.             // Return the character count including the begin/end quote characters and enclosed string.
  3528.             //
  3529.             returnValue = (pos - beginPos);
  3530.             return true;
  3531.         }
  3532.        
  3533.        
  3534. /*=================================DoStrictParse==================================
  3535.         **Action: Do DateTime parsing using the format in formatParam.
  3536.         **Returns: The parsed DateTime.
  3537.         **Arguments:
  3538.         **Exceptions:
  3539.         **
  3540.         **Notes:
  3541.         **  When the following general formats are used, InvariantInfo is used in dtfi:
  3542.         **      'r', 'R', 's'.
  3543.         **  When the following general formats are used, the time is assumed to be in Universal time.
  3544.         **
  3545.         **Limitations:
  3546.         **  Only GregarianCalendar is supported for now.
  3547.         **  Only support GMT timezone.
  3548.         ==============================================================================*/       
  3549.        
  3550.         private static bool DoStrictParse(string s, string formatParam, DateTimeStyles styles, DateTimeFormatInfo dtfi, ref DateTimeResult result)
  3551.         {
  3552.            
  3553.             bool bTimeOnly = false;
  3554.             ParsingInfo parseInfo = new ParsingInfo();
  3555.             parseInfo.Init();
  3556.            
  3557.             parseInfo.calendar = dtfi.Calendar;
  3558.             parseInfo.fAllowInnerWhite = ((styles & DateTimeStyles.AllowInnerWhite) != 0);
  3559.             parseInfo.fAllowTrailingWhite = ((styles & DateTimeStyles.AllowTrailingWhite) != 0);
  3560.            
  3561.             if (formatParam.Length == 1) {
  3562.                 formatParam = ExpandPredefinedFormat(formatParam, ref dtfi, ref parseInfo, ref result);
  3563.             }
  3564.             result.calendar = parseInfo.calendar;
  3565.            
  3566.             if (parseInfo.calendar.ID == Calendar.CAL_HEBREW) {
  3567.                 parseInfo.parseNumberDelegate = m_hebrewNumberParser;
  3568.                 parseInfo.fCustomNumberParser = true;
  3569.             }
  3570.            
  3571.             // Reset these values to negative one so that we could throw exception
  3572.             // if we have parsed every item twice.
  3573.             result.Hour = result.Minute = result.Second = -1;
  3574.            
  3575.             __DTString format = new __DTString(formatParam, dtfi, false);
  3576.             __DTString str = new __DTString(s, dtfi, false);
  3577.            
  3578.             if (parseInfo.fAllowTrailingWhite) {
  3579.                 // Trim trailing spaces if AllowTrailingWhite.
  3580.                 format.TrimTail();
  3581.                 format.RemoveTrailingInQuoteSpaces();
  3582.                 str.TrimTail();
  3583.             }
  3584.            
  3585.             if ((styles & DateTimeStyles.AllowLeadingWhite) != 0) {
  3586.                 format.SkipWhiteSpaces();
  3587.                 format.RemoveLeadingInQuoteSpaces();
  3588.                 str.SkipWhiteSpaces();
  3589.             }
  3590.            
  3591.             //
  3592.             // Scan every character in format and match the pattern in str.
  3593.             //
  3594.             while (format.GetNext()) {
  3595.                 // We trim inner spaces here, so that we will not eat trailing spaces when
  3596.                 // AllowTrailingWhite is not used.
  3597.                 if (parseInfo.fAllowInnerWhite) {
  3598.                     str.SkipWhiteSpaces();
  3599.                 }
  3600.                 if (!ParseByFormat(ref str, ref format, ref parseInfo, dtfi, ref result)) {
  3601.                     return (false);
  3602.                 }
  3603.             }
  3604.             if (str.Index < str.Value.Length - 1) {
  3605.                 // There are still remaining character in str.
  3606.                 result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3607.                 return false;
  3608.             }
  3609.            
  3610.             if (parseInfo.fUseTwoDigitYear && ((dtfi.FormatFlags & DateTimeFormatFlags.UseHebrewRule) == 0)) {
  3611.                 // A two digit year value is expected. Check if the parsed year value is valid.
  3612.                 if (result.Year >= 100) {
  3613.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3614.                     return false;
  3615.                 }
  3616.                 result.Year = parseInfo.calendar.ToFourDigitYear(result.Year);
  3617.             }
  3618.            
  3619.             if (parseInfo.fUseHour12) {
  3620.                 if (parseInfo.timeMark == TM.NotSet) {
  3621.                     // hh is used, but no AM/PM designator is specified.
  3622.                     // Assume the time is AM.
  3623.                     // Don't throw exceptions in here becasue it is very confusing for the caller.
  3624.                     // I always got confused myself when I use "hh:mm:ss" to parse a time string,
  3625.                     // and ParseExact() throws on me (because I didn't use the 24-hour clock 'HH').
  3626.                     parseInfo.timeMark = TM.AM;
  3627.                 }
  3628.                 if (result.Hour > 12) {
  3629.                     // AM/PM is used, but the value for HH is too big.
  3630.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDateTime", null);
  3631.                     return false;
  3632.                 }
  3633.                 if (parseInfo.timeMark == TM.AM) {
  3634.                     if (result.Hour == 12) {
  3635.                         result.Hour = 0;
  3636.                     }
  3637.                 }
  3638.                 else {
  3639.                     result.Hour = (result.Hour == 12) ? 12 : result.Hour + 12;
  3640.                 }
  3641.             }
  3642.            
  3643.             // Check if the parased string only contains hour/minute/second values.
  3644.             bTimeOnly = (result.Year == -1 && result.Month == -1 && result.Day == -1);
  3645.             CheckDefaultDateTime(ref result, ref parseInfo.calendar, styles);
  3646.            
  3647.             if (!bTimeOnly && dtfi.HasYearMonthAdjustment) {
  3648.                 if (!dtfi.YearMonthAdjustment(ref result.Year, ref result.Month, ((result.flags & ParseFlags.ParsedMonthName) != 0))) {
  3649.                     result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  3650.                     return false;
  3651.                 }
  3652.             }
  3653.             if (!parseInfo.calendar.TryToDateTime(result.Year, result.Month, result.Day, result.Hour, result.Minute, result.Second, 0, result.era, out result.parsedDate)) {
  3654.                 result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar", null);
  3655.                 return false;
  3656.             }
  3657.             if (result.fraction > 0) {
  3658.                 result.parsedDate = result.parsedDate.AddTicks((long)Math.Round(result.fraction * Calendar.TicksPerSecond));
  3659.             }
  3660.            
  3661.             //
  3662.             // We have to check day of week before we adjust to the time zone.
  3663.             // It is because the value of day of week may change after adjusting
  3664.             // to the time zone.
  3665.             //
  3666.             if (parseInfo.dayOfWeek != -1) {
  3667.                 //
  3668.                 // Check if day of week is correct.
  3669.                 //
  3670.                 if (parseInfo.dayOfWeek != (int)parseInfo.calendar.GetDayOfWeek(result.parsedDate)) {
  3671.                     result.SetFailure(ParseFailureKind.Format, "Format_BadDayOfWeek", null);
  3672.                     return false;
  3673.                 }
  3674.             }
  3675.            
  3676.            
  3677.             if (!DetermineTimeZoneAdjustments(ref result, styles, bTimeOnly)) {
  3678.                 return false;
  3679.             }
  3680.             return true;
  3681.         }
  3682.        
  3683.         private static Exception GetDateTimeParseException(ref DateTimeResult result)
  3684.         {
  3685.             switch (result.failure) {
  3686.                 case ParseFailureKind.ArgumentNull:
  3687.                     return new ArgumentNullException(result.failureArgumentName, Environment.GetResourceString(result.failureMessageID));
  3688.                 case ParseFailureKind.Format:
  3689.                     return new FormatException(Environment.GetResourceString(result.failureMessageID));
  3690.                 case ParseFailureKind.FormatWithParameter:
  3691.                     return new FormatException(Environment.GetResourceString(result.failureMessageID, result.failureMessageFormatArgument));
  3692.                 case ParseFailureKind.FormatBadDateTimeCalendar:
  3693.                     return new FormatException(Environment.GetResourceString(result.failureMessageID, result.calendar));
  3694.                 default:
  3695.                     BCLDebug.Assert(false, "Unkown DateTimeParseFailure: " + result);
  3696.                     return null;
  3697.                
  3698.             }
  3699.         }
  3700.     }
  3701.    
  3702.    
  3703.     //
  3704.     // This is a string parsing helper which wraps a String object.
  3705.     // It has a Index property which tracks
  3706.     // the current parsing pointer of the string.
  3707.     //
  3708.     internal struct __DTString
  3709.     {
  3710.        
  3711.         //
  3712.         // Value propery: stores the real string to be parsed.
  3713.         //
  3714.         internal string Value;
  3715.        
  3716.         //
  3717.         // Index property: points to the character that we are currently parsing.
  3718.         //
  3719.         internal int Index;
  3720.        
  3721.         // The length of Value string.
  3722.         internal int len;
  3723.        
  3724.         // The current chracter to be looked at.
  3725.         internal char m_current;
  3726.        
  3727.         private CompareInfo m_info;
  3728.         // Flag to indicate if we encouter an digit, we should check for token or not.
  3729.         // In some cultures, such as mn-MN, it uses "\x0031\x00a0\x0434\x04af\x0433\x044d\x044d\x0440\x00a0\x0441\x0430\x0440" in month names.
  3730.         private bool m_checkDigitToken;
  3731.        
  3732.         internal __DTString(string str, DateTimeFormatInfo dtfi, bool checkDigitToken) : this(str, dtfi)
  3733.         {
  3734.             m_checkDigitToken = checkDigitToken;
  3735.         }
  3736.        
  3737.         internal __DTString(string str, DateTimeFormatInfo dtfi)
  3738.         {
  3739.             Index = -1;
  3740.             Value = str;
  3741.             len = Value.Length;
  3742.            
  3743.             m_current = '\0';
  3744.             if (dtfi != null) {
  3745.                 m_info = dtfi.CompareInfo;
  3746.                 m_checkDigitToken = ((dtfi.FormatFlags & DateTimeFormatFlags.UseDigitPrefixInTokens) != 0);
  3747.             }
  3748.             else {
  3749.                 m_info = Thread.CurrentThread.CurrentCulture.CompareInfo;
  3750.                 m_checkDigitToken = false;
  3751.             }
  3752.         }
  3753.        
  3754.         internal CompareInfo CompareInfo {
  3755.             get { return m_info; }
  3756.         }
  3757.        
  3758.         //
  3759.         // Advance the Index.
  3760.         // Return true if Index is NOT at the end of the string.
  3761.         //
  3762.         // Typical usage:
  3763.         // while (str.GetNext())
  3764.         // {
  3765.         // char ch = str.GetChar()
  3766.         // }
  3767.         internal bool GetNext()
  3768.         {
  3769.             Index++;
  3770.             if (Index < len) {
  3771.                 m_current = Value[Index];
  3772.                 return (true);
  3773.             }
  3774.             return (false);
  3775.         }
  3776.        
  3777.         internal bool Advance(int count)
  3778.         {
  3779.             BCLDebug.Assert(Index + count <= len, "__DTString::Advance: Index + count <= len");
  3780.             Index += count;
  3781.             if (Index < len) {
  3782.                 m_current = Value[Index];
  3783.                 return (true);
  3784.             }
  3785.             return (false);
  3786.         }
  3787.        
  3788.        
  3789.         // Used by DateTime.Parse() to get the next token.
  3790.         internal void GetRegularToken(out TokenType tokenType, out int tokenValue, DateTimeFormatInfo dtfi)
  3791.         {
  3792.             tokenValue = 0;
  3793.             if (Index >= len) {
  3794.                 tokenType = TokenType.EndOfString;
  3795.                 return;
  3796.             }
  3797.            
  3798.             tokenType = TokenType.UnknownToken;
  3799.             Start:
  3800.            
  3801.             if (DateTimeParse.IsDigit(m_current)) {
  3802.                 // This is a digit.
  3803.                 tokenValue = m_current - '0';
  3804.                 int value;
  3805.                 int start = Index;
  3806.                
  3807.                 //
  3808.                 // Collect other digits.
  3809.                 //
  3810.                 while (++Index < len) {
  3811.                     m_current = Value[Index];
  3812.                     value = m_current - '0';
  3813.                     if (value >= 0 && value <= 9) {
  3814.                         tokenValue = tokenValue * 10 + value;
  3815.                     }
  3816.                     else {
  3817.                         break;
  3818.                     }
  3819.                 }
  3820.                 if (Index - start > DateTimeParse.MaxDateTimeNumberDigits) {
  3821.                     tokenType = TokenType.NumberToken;
  3822.                     tokenValue = -1;
  3823.                 }
  3824.                 else if (Index - start < 3) {
  3825.                     tokenType = TokenType.NumberToken;
  3826.                 }
  3827.                 else {
  3828.                     // If there are more than 3 digits, assume that it's a year value.
  3829.                     tokenType = TokenType.YearNumberToken;
  3830.                 }
  3831.                 if (m_checkDigitToken) {
  3832.                     int save = Index;
  3833.                     char saveCh = m_current;
  3834.                     // Re-scan using the staring Index to see if this is a token.
  3835.                     Index = start;
  3836.                     // To include the first digit.
  3837.                     m_current = Value[Index];
  3838.                     TokenType tempType;
  3839.                     int tempValue;
  3840.                     // This DTFI has tokens starting with digits.
  3841.                     // E.g. mn-MN has month name like "\x0031\x00a0\x0434\x04af\x0433\x044d\x044d\x0440\x00a0\x0441\x0430\x0440"
  3842.                     if (dtfi.Tokenize(TokenType.RegularTokenMask, out tempType, out tempValue, ref this)) {
  3843.                         tokenType = tempType;
  3844.                         tokenValue = tempValue;
  3845.                         // This is a token, so the Index has been advanced propertly in DTFI.Tokenizer().
  3846.                     }
  3847.                     else {
  3848.                         // Use the number token value.
  3849.                         // Restore the index.
  3850.                         Index = save;
  3851.                         m_current = saveCh;
  3852.                     }
  3853.                    
  3854.                 }
  3855.                
  3856.             }
  3857.             else if (Char.IsWhiteSpace(m_current)) {
  3858.                 // Just skip to the next character.
  3859.                 while (++Index < len) {
  3860.                     m_current = Value[Index];
  3861.                     if (!(Char.IsWhiteSpace(m_current))) {
  3862.                         goto Start;
  3863.                     }
  3864.                 }
  3865.                 // We have reached the end of string.
  3866.                 tokenType = TokenType.EndOfString;
  3867.             }
  3868.             else {
  3869.                 dtfi.Tokenize(TokenType.RegularTokenMask, out tokenType, out tokenValue, ref this);
  3870.             }
  3871.         }
  3872.        
  3873.         internal TokenType GetSeparatorToken(DateTimeFormatInfo dtfi)
  3874.         {
  3875.             TokenType tokenType;
  3876.             if (!SkipWhiteSpaceCurrent()) {
  3877.                 // Reach the end of the string.
  3878.                 return (TokenType.SEP_End);
  3879.             }
  3880.             if (!DateTimeParse.IsDigit(m_current)) {
  3881.                 // Not a digit. Tokenize it.
  3882.                 int tokenValue;
  3883.                 bool found = dtfi.Tokenize(TokenType.SeparatorTokenMask, out tokenType, out tokenValue, ref this);
  3884.                 if (!found) {
  3885.                     tokenType = TokenType.SEP_Space;
  3886.                 }
  3887.             }
  3888.             else {
  3889.                 // Do nothing here. If we see a number, it will not be a separator. There is no need wasting time trying to find the
  3890.                 // separator token.
  3891.                 tokenType = TokenType.SEP_Space;
  3892.             }
  3893.             return (tokenType);
  3894.         }
  3895.        
  3896.         internal bool MatchSpecifiedWord(string target)
  3897.         {
  3898.             return MatchSpecifiedWord(target, target.Length + Index);
  3899.         }
  3900.        
  3901.         internal bool MatchSpecifiedWord(string target, int endIndex)
  3902.         {
  3903.             int count = endIndex - Index;
  3904.            
  3905.             if (count != target.Length) {
  3906.                 return false;
  3907.             }
  3908.            
  3909.             if (Index + count > len) {
  3910.                 return false;
  3911.             }
  3912.            
  3913.             return (m_info.Compare(Value, Index, count, target, 0, count, CompareOptions.IgnoreCase) == 0);
  3914.         }
  3915.        
  3916.         private static char[] WhiteSpaceChecks = new char[] {' ', ' '};
  3917.        
  3918.         internal bool MatchSpecifiedWords(string target, bool checkWordBoundary, ref int matchLength)
  3919.         {
  3920.             int valueRemaining = Value.Length - Index;
  3921.             matchLength = target.Length;
  3922.            
  3923.             if (matchLength > valueRemaining || m_info.Compare(Value, Index, matchLength, target, 0, matchLength, CompareOptions.IgnoreCase) != 0) {
  3924.                 // Check word by word
  3925.                 int targetPosition = 0;
  3926.                 // Where we are in the target string
  3927.                 int thisPosition = Index;
  3928.                 // Where we are in this string
  3929.                 int wsIndex = target.IndexOfAny(WhiteSpaceChecks, targetPosition);
  3930.                 if (wsIndex == -1) {
  3931.                     return false;
  3932.                 }
  3933.                 do {
  3934.                     int segmentLength = wsIndex - targetPosition;
  3935.                     if (thisPosition >= Value.Length - segmentLength) {
  3936.                         // Subtraction to prevent overflow.
  3937.                         return false;
  3938.                     }
  3939.                     if (segmentLength == 0) {
  3940.                         // If segmentLength == 0, it means that we have leading space in the target string.
  3941.                         // In that case, skip the leading spaces in the target and this string.
  3942.                         matchLength--;
  3943.                     }
  3944.                     else {
  3945.                         // Make sure we also have whitespace in the input string
  3946.                         if (!Char.IsWhiteSpace(Value[thisPosition + segmentLength])) {
  3947.                             return false;
  3948.                         }
  3949.                         if (m_info.Compare(Value, thisPosition, segmentLength, target, targetPosition, segmentLength, CompareOptions.IgnoreCase) != 0) {
  3950.                             return false;
  3951.                         }
  3952.                         // Advance the input string
  3953.                         thisPosition = thisPosition + segmentLength + 1;
  3954.                     }
  3955.                     // Advance our target string
  3956.                     targetPosition = wsIndex + 1;
  3957.                    
  3958.                    
  3959.                     // Skip past multiple whitespace
  3960.                     while (thisPosition < Value.Length && Char.IsWhiteSpace(Value[thisPosition])) {
  3961.                         thisPosition++;
  3962.                         matchLength++;
  3963.                     }
  3964.                 }
  3965.                 while ((wsIndex = target.IndexOfAny(WhiteSpaceChecks, targetPosition)) >= 0);
  3966.                 // now check the last segment;
  3967.                 if (targetPosition < target.Length) {
  3968.                     int segmentLength = target.Length - targetPosition;
  3969.                     if (thisPosition > Value.Length - segmentLength) {
  3970.                         return false;
  3971.                     }
  3972.                     if (m_info.Compare(Value, thisPosition, segmentLength, target, targetPosition, segmentLength, CompareOptions.IgnoreCase) != 0) {
  3973.                         return false;
  3974.                     }
  3975.                 }
  3976.             }
  3977.            
  3978.             if (checkWordBoundary) {
  3979.                 int nextCharIndex = Index + matchLength;
  3980.                 if (nextCharIndex < Value.Length) {
  3981.                     if (Char.IsLetter(Value[nextCharIndex])) {
  3982.                         return (false);
  3983.                     }
  3984.                 }
  3985.             }
  3986.             return (true);
  3987.         }
  3988.        
  3989.         //
  3990.         // Check to see if the string starting from Index is a prefix of
  3991.         // str.
  3992.         // If a match is found, true value is returned and Index is updated to the next character to be parsed.
  3993.         // Otherwise, Index is unchanged.
  3994.         //
  3995.         internal bool Match(string str)
  3996.         {
  3997.             if (++Index >= len) {
  3998.                 return (false);
  3999.             }
  4000.            
  4001.             if (str.Length > (Value.Length - Index)) {
  4002.                 return false;
  4003.             }
  4004.            
  4005.             if (m_info.Compare(Value, Index, str.Length, str, 0, str.Length, CompareOptions.Ordinal) == 0) {
  4006.                 // Update the Index to the end of the matching string.
  4007.                 // So the following GetNext()/Match() opeartion will get
  4008.                 // the next character to be parsed.
  4009.                 Index += (str.Length - 1);
  4010.                 return (true);
  4011.             }
  4012.             return (false);
  4013.         }
  4014.        
  4015.         internal bool Match(char ch)
  4016.         {
  4017.             if (++Index >= len) {
  4018.                 return (false);
  4019.             }
  4020.             if (Value[Index] == ch) {
  4021.                 m_current = ch;
  4022.                 return (true);
  4023.             }
  4024.             Index--;
  4025.             return (false);
  4026.         }
  4027.        
  4028.         //
  4029.         // Actions: From the current position, try matching the longest word in the specified string array.
  4030.         // E.g. words[] = {"AB", "ABC", "ABCD"}, if the current position points to a substring like "ABC DEF",
  4031.         // MatchLongestWords(words, ref MaxMatchStrLen) will return 1 (the index), and maxMatchLen will be 3.
  4032.         // Returns:
  4033.         // The index that contains the longest word to match
  4034.         // Arguments:
  4035.         // words The string array that contains words to search.
  4036.         // maxMatchStrLen [in/out] the initailized maximum length. This parameter can be used to
  4037.         // find the longest match in two string arrays.
  4038.         //
  4039.         internal int MatchLongestWords(string[] words, ref int maxMatchStrLen)
  4040.         {
  4041.             int result = -1;
  4042.             for (int i = 0; i < words.Length; i++) {
  4043.                 string word = words[i];
  4044.                 int matchLength = word.Length;
  4045.                 if (MatchSpecifiedWords(word, false, ref matchLength)) {
  4046.                     if (matchLength > maxMatchStrLen) {
  4047.                         maxMatchStrLen = matchLength;
  4048.                         result = i;
  4049.                     }
  4050.                 }
  4051.             }
  4052.            
  4053.             return (result);
  4054.         }
  4055.        
  4056.         //
  4057.         // Get the number of repeat character after the current character.
  4058.         // For a string "hh:mm:ss" at Index of 3. GetRepeatCount() = 2, and Index
  4059.         // will point to the second ':'.
  4060.         //
  4061.         internal int GetRepeatCount()
  4062.         {
  4063.             char repeatChar = Value[Index];
  4064.             int pos = Index + 1;
  4065.             while ((pos < len) && (Value[pos] == repeatChar)) {
  4066.                 pos++;
  4067.             }
  4068.             int repeatCount = (pos - Index);
  4069.             // Update the Index to the end of the repeated characters.
  4070.             // So the following GetNext() opeartion will get
  4071.             // the next character to be parsed.
  4072.             Index = pos - 1;
  4073.             return (repeatCount);
  4074.         }
  4075.        
  4076.         // Return false when end of string is encountered or a non-digit character is found.
  4077.         internal bool GetNextDigit()
  4078.         {
  4079.             if (++Index >= len) {
  4080.                 return (false);
  4081.             }
  4082.             return (DateTimeParse.IsDigit(Value[Index]));
  4083.         }
  4084.        
  4085.         //
  4086.         // Get the current character.
  4087.         //
  4088.         internal char GetChar()
  4089.         {
  4090.             BCLDebug.Assert(Index >= 0 && Index < len, "Index >= 0 && Index < len");
  4091.             return (Value[Index]);
  4092.         }
  4093.        
  4094.         //
  4095.         // Convert the current character to a digit, and return it.
  4096.         //
  4097.         internal int GetDigit()
  4098.         {
  4099.             BCLDebug.Assert(Index >= 0 && Index < len, "Index >= 0 && Index < len");
  4100.             BCLDebug.Assert(DateTimeParse.IsDigit(Value[Index]), "IsDigit(Value[Index])");
  4101.             return (Value[Index] - '0');
  4102.         }
  4103.        
  4104.         //
  4105.         // Eat White Space ahead of the current position
  4106.         //
  4107.         // Return false if end of string is encountered.
  4108.         //
  4109.         internal void SkipWhiteSpaces()
  4110.         {
  4111.             // Look ahead to see if the next character
  4112.             // is a whitespace.
  4113.             while (Index + 1 < len) {
  4114.                 char ch = Value[Index + 1];
  4115.                 if (!Char.IsWhiteSpace(ch)) {
  4116.                     return;
  4117.                 }
  4118.                 Index++;
  4119.             }
  4120.             return;
  4121.         }
  4122.        
  4123.         //
  4124.         // Skip white spaces from the current position
  4125.         //
  4126.         // Return false if end of string is encountered.
  4127.         //
  4128.         internal bool SkipWhiteSpaceCurrent()
  4129.         {
  4130.             if (Index >= len) {
  4131.                 return (false);
  4132.             }
  4133.            
  4134.             if (!Char.IsWhiteSpace(m_current)) {
  4135.                 return (true);
  4136.             }
  4137.            
  4138.             while (++Index < len) {
  4139.                 m_current = Value[Index];
  4140.                 if (!Char.IsWhiteSpace(m_current)) {
  4141.                     return (true);
  4142.                 }
  4143.                 // Nothing here.
  4144.             }
  4145.             return (false);
  4146.         }
  4147.        
  4148.         internal void TrimTail()
  4149.         {
  4150.             int i = len - 1;
  4151.             while (i >= 0 && Char.IsWhiteSpace(Value[i])) {
  4152.                 i--;
  4153.             }
  4154.             Value = Value.Substring(0, i + 1);
  4155.             len = Value.Length;
  4156.         }
  4157.        
  4158.         // Trim the trailing spaces within a quoted string.
  4159.         // Call this after TrimTail() is done.
  4160.         internal void RemoveTrailingInQuoteSpaces()
  4161.         {
  4162.             int i = len - 1;
  4163.             if (i <= 1) {
  4164.                 return;
  4165.             }
  4166.             char ch = Value[i];
  4167.             // Check if the last character is a quote.
  4168.             if (ch == '\'' || ch == '"') {
  4169.                 if (Char.IsWhiteSpace(Value[i - 1])) {
  4170.                     i--;
  4171.                     while (i >= 1 && Char.IsWhiteSpace(Value[i - 1])) {
  4172.                         i--;
  4173.                     }
  4174.                     Value = Value.Remove(i, Value.Length - 1 - i);
  4175.                     len = Value.Length;
  4176.                 }
  4177.             }
  4178.         }
  4179.        
  4180.         // Trim the leading spaces within a quoted string.
  4181.         // Call this after the leading spaces before quoted string are trimmed.
  4182.         internal void RemoveLeadingInQuoteSpaces()
  4183.         {
  4184.             if (len <= 2) {
  4185.                 return;
  4186.             }
  4187.             int i = 0;
  4188.             char ch = Value[i];
  4189.             // Check if the last character is a quote.
  4190.             if (ch == '\'' || ch == '"') {
  4191.                 while ((i + 1) < len && Char.IsWhiteSpace(Value[i + 1])) {
  4192.                     i++;
  4193.                 }
  4194.                 if (i != 0) {
  4195.                     Value = Value.Remove(1, i);
  4196.                     len = Value.Length;
  4197.                 }
  4198.             }
  4199.         }
  4200.        
  4201.         internal DTSubString GetSubString()
  4202.         {
  4203.             DTSubString sub = new DTSubString();
  4204.             sub.index = Index;
  4205.             sub.s = Value;
  4206.             while (Index + sub.length < len) {
  4207.                 DTSubStringType currentType;
  4208.                 char ch = Value[Index + sub.length];
  4209.                 if (ch >= '0' && ch <= '9') {
  4210.                     currentType = DTSubStringType.Number;
  4211.                 }
  4212.                 else {
  4213.                     currentType = DTSubStringType.Other;
  4214.                 }
  4215.                
  4216.                 if (sub.length == 0) {
  4217.                     sub.type = currentType;
  4218.                 }
  4219.                 else {
  4220.                     if (sub.type != currentType) {
  4221.                         break;
  4222.                     }
  4223.                 }
  4224.                 sub.length++;
  4225.                 if (currentType == DTSubStringType.Number) {
  4226.                     // Incorporate the number into the value
  4227.                     // Limit the digits to prevent overflow
  4228.                     if (sub.length > DateTimeParse.MaxDateTimeNumberDigits) {
  4229.                         sub.type = DTSubStringType.Invalid;
  4230.                         return sub;
  4231.                     }
  4232.                     int number = ch - '0';
  4233.                     BCLDebug.Assert(number >= 0 && number <= 9, "number >= 0 && number <= 9");
  4234.                     sub.value = sub.value * 10 + number;
  4235.                 }
  4236.                 else {
  4237.                     // For non numbers, just return this length 1 token. This should be expanded
  4238.                     // to more types of thing if this parsing approach is used for things other
  4239.                     // than numbers and single characters
  4240.                     break;
  4241.                 }
  4242.             }
  4243.             if (sub.length == 0) {
  4244.                 sub.type = DTSubStringType.End;
  4245.                 return sub;
  4246.             }
  4247.            
  4248.             return sub;
  4249.         }
  4250.        
  4251.         internal void ConsumeSubString(DTSubString sub)
  4252.         {
  4253.             BCLDebug.Assert(sub.index == Index, "sub.index == Index");
  4254.             BCLDebug.Assert(sub.index + sub.length <= len, "sub.index + sub.length <= len");
  4255.             Index = sub.index + sub.length;
  4256.             if (Index < len) {
  4257.                 m_current = Value[Index];
  4258.             }
  4259.         }
  4260.        
  4261.        
  4262.     }
  4263.    
  4264.     internal enum DTSubStringType
  4265.     {
  4266.         Unknown = 0,
  4267.         Invalid = 1,
  4268.         Number = 2,
  4269.         End = 3,
  4270.         Other = 4
  4271.     }
  4272.    
  4273.     internal struct DTSubString
  4274.     {
  4275.         internal string s;
  4276.         internal Int32 index;
  4277.         internal Int32 length;
  4278.         internal DTSubStringType type;
  4279.         internal Int32 value;
  4280.        
  4281.         internal char this[Int32 relativeIndex]
  4282.         {
  4283.             get { return s[index + relativeIndex]; }
  4284.         }
  4285.     }
  4286.    
  4287.     //
  4288.     // The buffer to store the parsing token.
  4289.     //
  4290.     internal struct DateTimeToken
  4291.     {
  4292.         internal DateTimeParse.DTT dtt;
  4293.         // Store the token
  4294.         internal TokenType suffix;
  4295.         // Store the CJK Year/Month/Day suffix (if any)
  4296.         internal int num;
  4297.         // Store the number that we are parsing (if any)
  4298.     }
  4299.    
  4300.     //
  4301.     // The buffer to store temporary parsing information.
  4302.     //
  4303.     unsafe internal struct DateTimeRawInfo
  4304.     {
  4305.         private int* num;
  4306.         internal int numCount;
  4307.         internal int month;
  4308.         internal int year;
  4309.         internal int dayOfWeek;
  4310.         internal int era;
  4311.         internal DateTimeParse.TM timeMark;
  4312.         internal double fraction;
  4313.         //
  4314.         //
  4315.         internal bool timeZone;
  4316.        
  4317.         internal void Init(int* numberBuffer)
  4318.         {
  4319.             month = -1;
  4320.             year = -1;
  4321.             dayOfWeek = -1;
  4322.             era = -1;
  4323.             timeMark = DateTimeParse.TM.NotSet;
  4324.             fraction = -1;
  4325.             num = numberBuffer;
  4326.         }
  4327.         unsafe internal void AddNumber(int value)
  4328.         {
  4329.             num[numCount++] = value;
  4330.         }
  4331.         unsafe internal int GetNumber(int index)
  4332.         {
  4333.             return num[index];
  4334.         }
  4335.     }
  4336.    
  4337.     internal enum ParseFailureKind
  4338.     {
  4339.         None = 0,
  4340.         ArgumentNull = 1,
  4341.         Format = 2,
  4342.         FormatWithParameter = 3,
  4343.         FormatBadDateTimeCalendar = 4
  4344.         // FormatException when ArgumentOutOfRange is thrown by a Calendar.TryToDateTime().
  4345.     }
  4346.    
  4347.     [Flags()]
  4348.     internal enum ParseFlags
  4349.     {
  4350.         HaveYear = 1,
  4351.         HaveMonth = 2,
  4352.         HaveDay = 4,
  4353.         HaveHour = 8,
  4354.         HaveMinute = 16,
  4355.         HaveSecond = 32,
  4356.         HaveTime = 64,
  4357.         HaveDate = 128,
  4358.         TimeZoneUsed = 256,
  4359.         TimeZoneUtc = 512,
  4360.         ParsedMonthName = 1024
  4361.     }
  4362.    
  4363.     //
  4364.     // This will store the result of the parsing. And it will be eventually
  4365.     // used to construct a DateTime instance.
  4366.     //
  4367.     internal struct DateTimeResult
  4368.     {
  4369.         internal int Year;
  4370.         internal int Month;
  4371.         internal int Day;
  4372.         //
  4373.         // Set time defualt to 00:00:00.
  4374.         //
  4375.         internal int Hour;
  4376.         internal int Minute;
  4377.         internal int Second;
  4378.         internal double fraction;
  4379.        
  4380.         internal int era;
  4381.        
  4382.         internal ParseFlags flags;
  4383.        
  4384.         internal TimeSpan timeZoneOffset;
  4385.        
  4386.         internal Calendar calendar;
  4387.        
  4388.         internal DateTime parsedDate;
  4389.        
  4390.         internal ParseFailureKind failure;
  4391.         internal string failureMessageID;
  4392.         internal object failureMessageFormatArgument;
  4393.         internal string failureArgumentName;
  4394.        
  4395.         internal void Init()
  4396.         {
  4397.             Year = -1;
  4398.             Month = -1;
  4399.             Day = -1;
  4400.             fraction = -1;
  4401.             era = -1;
  4402.         }
  4403.        
  4404.         internal void SetDate(int year, int month, int day)
  4405.         {
  4406.             Year = year;
  4407.             Month = month;
  4408.             Day = day;
  4409.         }
  4410.         internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument)
  4411.         {
  4412.             this.failure = failure;
  4413.             this.failureMessageID = failureMessageID;
  4414.             this.failureMessageFormatArgument = failureMessageFormatArgument;
  4415.         }
  4416.        
  4417.         internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument, string failureArgumentName)
  4418.         {
  4419.             this.failure = failure;
  4420.             this.failureMessageID = failureMessageID;
  4421.             this.failureMessageFormatArgument = failureMessageFormatArgument;
  4422.             this.failureArgumentName = failureArgumentName;
  4423.         }
  4424.        
  4425.        
  4426.        
  4427.        
  4428.     }
  4429.    
  4430.     // This is the helper data structure used in ParseExact().
  4431.     internal struct ParsingInfo
  4432.     {
  4433.        
  4434.         internal Calendar calendar;
  4435.         internal int dayOfWeek;
  4436.         internal DateTimeParse.TM timeMark;
  4437.        
  4438.         internal bool fUseHour12;
  4439.         internal bool fUseTwoDigitYear;
  4440.         internal bool fAllowInnerWhite;
  4441.         internal bool fAllowTrailingWhite;
  4442.         internal bool fCustomNumberParser;
  4443.         internal DateTimeParse.MatchNumberDelegate parseNumberDelegate;
  4444.        
  4445.         internal void Init()
  4446.         {
  4447.             dayOfWeek = -1;
  4448.             timeMark = DateTimeParse.TM.NotSet;
  4449.         }
  4450.        
  4451.     }
  4452.    
  4453.     //
  4454.     // The type of token that will be returned by DateTimeFormatInfo.Tokenize().
  4455.     //
  4456.     internal enum TokenType
  4457.     {
  4458.         // The valid token should start from 1.
  4459.        
  4460.         // Regular tokens. The range is from 0x00 ~ 0xff.
  4461.         NumberToken = 1,
  4462.         // The number. E.g. "12"
  4463.         YearNumberToken = 2,
  4464.         // The number which is considered as year number, which has 3 or more digits. E.g. "2003"
  4465.         Am = 3,
  4466.         // AM timemark. E.g. "AM"
  4467.         Pm = 4,
  4468.         // PM timemark. E.g. "PM"
  4469.         MonthToken = 5,
  4470.         // A word (or words) that represents a month name. E.g. "March"
  4471.         EndOfString = 6,
  4472.         // End of string
  4473.         DayOfWeekToken = 7,
  4474.         // A word (or words) that represents a day of week name. E.g. "Monday" or "Mon"
  4475.         TimeZoneToken = 8,
  4476.         // A word that represents a timezone name. E.g. "GMT"
  4477.         EraToken = 9,
  4478.         // A word that represents a era name. E.g. "A.D."
  4479.         DateWordToken = 10,
  4480.         // A word that can appear in a DateTime string, but serves no parsing semantics. E.g. "de" in Spanish culture.
  4481.         UnknownToken = 11,
  4482.         // An unknown word, which signals an error in parsing.
  4483.         HebrewNumber = 12,
  4484.         // A number that is composed of Hebrew text. Hebrew calendar uses Hebrew digits for year values, month values, and day values.
  4485.         JapaneseEraToken = 13,
  4486.         // Era name for JapaneseCalendar
  4487.         TEraToken = 14,
  4488.         // Era name for TaiwanCalenadr
  4489.         IgnorableSymbol = 15,
  4490.         // A separator like "," that is equivalent to whitespace
  4491.        
  4492.         // Separator tokens.
  4493.         SEP_Unk = 256,
  4494.         // Unknown separator.
  4495.         SEP_End = 512,
  4496.         // The end of the parsing string.
  4497.         SEP_Space = 768,
  4498.         // Whitespace (including comma).
  4499.         SEP_Am = 1024,
  4500.         // AM timemark. E.g. "AM"
  4501.         SEP_Pm = 1280,
  4502.         // PM timemark. E.g. "PM"
  4503.         SEP_Date = 1536,
  4504.         // date separator. E.g. "/"
  4505.         SEP_Time = 1792,
  4506.         // time separator. E.g. ":"
  4507.         SEP_YearSuff = 2048,
  4508.         // Chinese/Japanese/Korean year suffix.
  4509.         SEP_MonthSuff = 2304,
  4510.         // Chinese/Japanese/Korean month suffix.
  4511.         SEP_DaySuff = 2560,
  4512.         // Chinese/Japanese/Korean day suffix.
  4513.         SEP_HourSuff = 2816,
  4514.         // Chinese/Japanese/Korean hour suffix.
  4515.         SEP_MinuteSuff = 3072,
  4516.         // Chinese/Japanese/Korean minute suffix.
  4517.         SEP_SecondSuff = 3328,
  4518.         // Chinese/Japanese/Korean second suffix.
  4519.         SEP_LocalTimeMark = 3584,
  4520.         // 'T', used in ISO 8601 format.
  4521.         RegularTokenMask = 255,
  4522.         SeparatorTokenMask = 65280
  4523.     }
  4524. }

Developer Fusion