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

  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. namespace System.Globalization
  16. {
  17.     using System;
  18.     using System.Security;
  19.     using System.Threading;
  20.     using System.Collections;
  21.     using System.Runtime.Serialization;
  22.     using System.Security.Permissions;
  23.     using System.Runtime.InteropServices;
  24.     using System.Text;
  25.    
  26.     //
  27.     // Flags used to indicate different styles of month names.
  28.     // This is an internal flag used by internalGetMonthName().
  29.     // Use flag here in case that we need to provide a combination of these styles
  30.     // (such as month name of a leap year in genitive form. Not likely for now,
  31.     // but would like to keep the option open).
  32.     //
  33.    
  34.     [Flags()]
  35.     internal enum MonthNameStyles
  36.     {
  37.         Regular = 0,
  38.         Genitive = 1,
  39.         LeapYear = 2
  40.     }
  41.    
  42.     //
  43.     // Flags used to indicate special rule used in parsing/formatting
  44.     // for a specific DateTimeFormatInfo instance.
  45.     // This is an internal flag.
  46.     //
  47.     // This flag is different from MonthNameStyles because this flag
  48.     // can be expanded to accomodate parsing behaviors like CJK month names
  49.     // or alternative month names, etc.
  50.    
  51.     [Flags()]
  52.     internal enum DateTimeFormatFlags
  53.     {
  54.         None = 0,
  55.         UseGenitiveMonth = 1,
  56.         UseLeapYearMonth = 2,
  57.         UseSpacesInMonthNames = 4,
  58.         // Has spaces or non-breaking space in the month names.
  59.         UseHebrewRule = 8,
  60.         // Format/Parse using the Hebrew calendar rule.
  61.         UseSpacesInDayNames = 16,
  62.         // Has spaces or non-breaking space in the day names.
  63.         UseDigitPrefixInTokens = 32,
  64.         // Has token starting with numbers.
  65.         NotInitialized = -1
  66.     }
  67.    
  68.    
  69.     [Serializable()]
  70.     [System.Runtime.InteropServices.ComVisible(true)]
  71.     public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
  72.     {
  73.        
  74.         // cache for the invarinat culture.
  75.         // invariantInfo is constant irrespective of your current culture.
  76.         private static DateTimeFormatInfo invariantInfo;
  77.        
  78.         // an index which points to a record in Culture Data Table.
  79.         [NonSerialized()]
  80.         internal CultureTableRecord m_cultureTableRecord;
  81.        
  82.         // The culture name used to create this DTFI.
  83.         [OptionalField(VersionAdded = 2)]
  84.         internal string m_name = null;
  85.        
  86.         // The language name of the culture used to create this DTFI.
  87.         [NonSerialized()]
  88.         internal string m_langName = null;
  89.        
  90.         // CompareInfo usually used by the parser.
  91.         [NonSerialized()]
  92.         internal CompareInfo m_compareInfo = null;
  93.        
  94.         // Flag to indicate if the specified calendar for this DTFI is the
  95.         // default calendar stored in the culture.nlp.
  96.         internal bool m_isDefaultCalendar;
  97.        
  98.         internal int CultureId {
  99.             get { return this.m_cultureTableRecord.CultureID; }
  100.         }
  101.        
  102.         //
  103.         //
  104.         //
  105.         //
  106.         //
  107.         internal bool bUseCalendarInfo = false;
  108.        
  109.         //
  110.         // Caches for various properties.
  111.         //
  112.         internal string amDesignator = null;
  113.         internal string pmDesignator = null;
  114.         internal string dateSeparator = null;
  115.         internal string longTimePattern = null;
  116.         internal string shortTimePattern = null;
  117.         internal string generalShortTimePattern = null;
  118.         internal string generalLongTimePattern = null;
  119.         internal string timeSeparator = null;
  120.         internal string monthDayPattern = null;
  121.        
  122.         // In case default time/date pattern included in the all patterns array then we always set it as first item.
  123.         // that is to be easy to know if we need to add the default pattern to the array when the array is requested.
  124.         // look at SetDefaultPatternAsFirstItem to see how we do that.
  125.         internal string[] allShortTimePatterns = null;
  126.         internal string[] allLongTimePatterns = null;
  127.        
  128.         //
  129.         // The following are constant values.
  130.         //
  131.         internal const string rfc1123Pattern = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'";
  132.         // The sortable pattern is based on ISO 8601.
  133.         internal const string sortableDateTimePattern = "yyyy'-'MM'-'dd'T'HH':'mm':'ss";
  134.         internal const string universalSortableDateTimePattern = "yyyy'-'MM'-'dd HH':'mm':'ss'Z'";
  135.        
  136.         //
  137.         // The following are affected by calendar settings.
  138.         //
  139.         internal Calendar calendar = null;
  140.        
  141.         internal int firstDayOfWeek = -1;
  142.         internal int calendarWeekRule = -1;
  143.        
  144.         internal string fullDateTimePattern = null;
  145.        
  146.         internal string longDatePattern = null;
  147.        
  148.         internal string shortDatePattern = null;
  149.        
  150.         internal string yearMonthPattern = null;
  151.        
  152.         internal string[] abbreviatedDayNames = null;
  153.        
  154.         [OptionalField(VersionAdded = 2)]
  155.         internal string[] m_superShortDayNames = null;
  156.        
  157.         internal string[] dayNames = null;
  158.         internal string[] abbreviatedMonthNames = null;
  159.         internal string[] monthNames = null;
  160.         // Cache the genitive month names that we retrieve from the data table.
  161.         [OptionalField(VersionAdded = 2)]
  162.         internal string[] genitiveMonthNames = null;
  163.        
  164.         // Cache the abbreviated genitive month names that we retrieve from the data table.
  165.         [OptionalField(VersionAdded = 2)]
  166.         internal string[] m_genitiveAbbreviatedMonthNames = null;
  167.        
  168.         // Cache the month names of a leap year that we retrieve from the data table.
  169.         [OptionalField(VersionAdded = 2)]
  170.         internal string[] leapYearMonthNames = null;
  171.        
  172.         // In case default time/date pattern included in the all patterns array then we always set it as first item.
  173.         // that is to be easy to know if we need to add the default pattern to the array when the array is requested.
  174.         // look at SetDefaultPatternAsFirstItem to see how we do that.
  175.        
  176.         [NonSerialized()]
  177.         // this is lazy intialized so no need to serialize it.
  178.         internal string[] allYearMonthPatterns = null;
  179.         internal string[] allShortDatePatterns = null;
  180.         internal string[] allLongDatePatterns = null;
  181.        
  182.        
  183.        
  184.         // Cache the era names for this DateTimeFormatInfo instance.
  185.         internal string[] m_eraNames = null;
  186.         internal string[] m_abbrevEraNames = null;
  187.         internal string[] m_abbrevEnglishEraNames = null;
  188.        
  189.         internal string[] m_dateWords = null;
  190.        
  191.         internal int[] optionalCalendars = null;
  192.        
  193.         private const int DEFAULT_ALL_DATETIMES_SIZE = 132;
  194.        
  195.         internal bool m_isReadOnly = false;
  196.         // This flag gives hints about if formatting/parsing should perform special code path for things like
  197.         // genitive form or leap year month names.
  198.         [OptionalField(VersionAdded = 2)]
  199.         internal DateTimeFormatFlags formatFlags = DateTimeFormatFlags.NotInitialized;
  200.        
  201.         private static Hashtable m_calendarNativeNames;
  202.         // Maps from calendar Id to calendar native name.
  203.         private static object s_InternalSyncObject;
  204.        
  205.         private static object InternalSyncObject {
  206.             get {
  207.                 if (s_InternalSyncObject == null) {
  208.                     object o = new object();
  209.                     Interlocked.CompareExchange(ref s_InternalSyncObject, o, null);
  210.                 }
  211.                 return s_InternalSyncObject;
  212.             }
  213.         }
  214.        
  215.         internal string CultureName {
  216.             get {
  217.                 if (m_name == null) {
  218.                     m_name = this.m_cultureTableRecord.SNAME;
  219.                 }
  220.                 return (m_name);
  221.             }
  222.         }
  223.        
  224.         internal string LanguageName {
  225.             get {
  226.                 if (m_langName == null) {
  227.                     m_langName = this.m_cultureTableRecord.SISO639LANGNAME;
  228.                 }
  229.                 return (m_langName);
  230.             }
  231.         }
  232.        
  233.         ////////////////////////////////////////////////////////////////////////////
  234.         //
  235.         // Create an array of string which contains the abbreviated day names.
  236.         //
  237.         ////////////////////////////////////////////////////////////////////////////
  238.        
  239.         private string[] GetAbbreviatedDayOfWeekNames()
  240.         {
  241.             if (abbreviatedDayNames == null) {
  242.                 if (abbreviatedDayNames == null) {
  243.                     string[] temp = null;
  244.                     if (!m_isDefaultCalendar) {
  245.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetAbbreviatedDayOfWeekNames] Expected Calendar.ID > 0");
  246.                         temp = CalendarTable.Default.SABBREVDAYNAMES(Calendar.ID);
  247.                     }
  248.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  249.                         temp = this.m_cultureTableRecord.SABBREVDAYNAMES;
  250.                     System.Threading.Thread.MemoryBarrier();
  251.                     abbreviatedDayNames = temp;
  252.                     BCLDebug.Assert(abbreviatedDayNames.Length == 7, "[DateTimeFormatInfo.GetAbbreviatedDayOfWeekNames] Expected 7 day names in a week");
  253.                 }
  254.             }
  255.             return (abbreviatedDayNames);
  256.         }
  257.        
  258.         ////////////////////////////////////////////////////////////////////////
  259.         //
  260.         // Action: Returns the string array of the one-letter day of week names.
  261.         // Returns:
  262.         // an array of one-letter day of week names
  263.         // Arguments:
  264.         // None
  265.         // Exceptions:
  266.         // None
  267.         //
  268.         ////////////////////////////////////////////////////////////////////////
  269.        
  270.         private string[] internalGetSuperShortDayNames()
  271.         {
  272.             if (this.m_superShortDayNames == null) {
  273.                 if (this.m_superShortDayNames == null) {
  274.                     string[] temp = null;
  275.                     if (!m_isDefaultCalendar) {
  276.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.internalGetSuperShortDayNames] Expected Calendar.ID > 0");
  277.                         temp = CalendarTable.Default.SSUPERSHORTDAYNAMES(Calendar.ID);
  278.                     }
  279.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  280.                         temp = this.m_cultureTableRecord.SSUPERSHORTDAYNAMES;
  281.                     System.Threading.Thread.MemoryBarrier();
  282.                     this.m_superShortDayNames = temp;
  283.                     BCLDebug.Assert(this.m_superShortDayNames.Length == 7, "[DateTimeFormatInfo.internalGetSuperShortDayNames] Expected 7 day names in a week");
  284.                 }
  285.             }
  286.             return (this.m_superShortDayNames);
  287.         }
  288.        
  289.         ////////////////////////////////////////////////////////////////////////////
  290.         //
  291.         // Create an array of string which contains the day names.
  292.         //
  293.         ////////////////////////////////////////////////////////////////////////////
  294.        
  295.         private string[] GetDayOfWeekNames()
  296.         {
  297.             if (dayNames == null) {
  298.                 if (dayNames == null) {
  299.                     string[] temp = null;
  300.                     if (!m_isDefaultCalendar) {
  301.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetDayOfWeekNames] Expected Calendar.ID > 0");
  302.                         temp = CalendarTable.Default.SDAYNAMES(Calendar.ID);
  303.                     }
  304.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  305.                         temp = this.m_cultureTableRecord.SDAYNAMES;
  306.                     System.Threading.Thread.MemoryBarrier();
  307.                     dayNames = temp;
  308.                     BCLDebug.Assert(dayNames.Length == 7, "[DateTimeFormatInfo.GetDayOfWeekNames] Expected 7 day names in a week");
  309.                 }
  310.             }
  311.             return (dayNames);
  312.         }
  313.        
  314.         ////////////////////////////////////////////////////////////////////////////
  315.         //
  316.         // Create an array of string which contains the abbreviated month names.
  317.         //
  318.         ////////////////////////////////////////////////////////////////////////////
  319.        
  320.         private string[] GetAbbreviatedMonthNames()
  321.         {
  322.             if (abbreviatedMonthNames == null) {
  323.                 if (abbreviatedMonthNames == null) {
  324.                     string[] temp = null;
  325.                     if (!m_isDefaultCalendar) {
  326.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetAbbreviatedMonthNames] Expected Calendar.ID > 0");
  327.                         temp = CalendarTable.Default.SABBREVMONTHNAMES(Calendar.ID);
  328.                     }
  329.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  330.                         temp = this.m_cultureTableRecord.SABBREVMONTHNAMES;
  331.                     System.Threading.Thread.MemoryBarrier();
  332.                     abbreviatedMonthNames = temp;
  333.                     BCLDebug.Assert(abbreviatedMonthNames.Length == 12 || abbreviatedMonthNames.Length == 13, "[DateTimeFormatInfo.GetAbbreviatedMonthNames] Expected 12 or 13 month names in a year");
  334.                 }
  335.             }
  336.             return (abbreviatedMonthNames);
  337.         }
  338.        
  339.        
  340.         ////////////////////////////////////////////////////////////////////////////
  341.         //
  342.         // Create an array of string which contains the month names.
  343.         //
  344.         ////////////////////////////////////////////////////////////////////////////
  345.        
  346.         private string[] GetMonthNames()
  347.         {
  348.             if (monthNames == null) {
  349.                 string[] temp = null;
  350.                 if (!m_isDefaultCalendar) {
  351.                     BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetMonthNames] Expected Calendar.ID > 0");
  352.                     temp = CalendarTable.Default.SMONTHNAMES(Calendar.ID);
  353.                 }
  354.                 if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  355.                     temp = this.m_cultureTableRecord.SMONTHNAMES;
  356.                 System.Threading.Thread.MemoryBarrier();
  357.                 monthNames = temp;
  358.                 BCLDebug.Assert(MonthNames.Length == 12 || MonthNames.Length == 13, "[DateTimeFormatInfo.GetMonthNames] Expected 12 or 13 month names in a year");
  359.             }
  360.            
  361.             return (monthNames);
  362.         }
  363.        
  364.        
  365.         public DateTimeFormatInfo()
  366.         {
  367.             //
  368.             // Invariant DateTimeFormatInfo doesn't have user-overriden values, so we pass false in useUserOverride.
  369.             //
  370.             this.m_cultureTableRecord = CultureInfo.InvariantCulture.m_cultureTableRecord;
  371.             // In Invariant culture, the default calendar store in culture.nlp is Gregorian localized.
  372.             // And the date/time pattern for invariant culture stored in
  373.             this.m_isDefaultCalendar = true;
  374.             this.calendar = GregorianCalendar.GetDefaultInstance();
  375.            
  376.             // We don't have to call the setter of Calendar property here because the Calendar getter
  377.             // will return Gregorian localized calendar by default.
  378.             InitializeOverridableProperties();
  379.         }
  380.        
  381.         internal DateTimeFormatInfo(CultureTableRecord cultureTable, int cultureID, Calendar cal)
  382.         {
  383.             this.m_cultureTableRecord = cultureTable;
  384.             // m_isDefaultCalendar is set in the setter of Calendar below.
  385.             this.Calendar = cal;
  386.         }
  387.        
  388.         #region Serialization
  389.         // The following fields are defined to keep the serialization compatibility with .NET V1.0/V1.1.
  390.         private int CultureID;
  391.         private bool m_useUserOverride;
  392.         private int nDataItem;
  393.        
  394.         [OnDeserialized()]
  395.         private void OnDeserialized(StreamingContext ctx)
  396.         {
  397.             BCLDebug.Assert(CultureID >= 0, "[DateTimeFormatInfo.OnDeserialized] clulture ID < 0");
  398.            
  399.             if (CultureTableRecord.IsCustomCultureId(CultureID))
  400.                 m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(m_name, m_useUserOverride);
  401.             else
  402.                 m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(CultureID, m_useUserOverride);
  403.            
  404.             if (calendar == null) {
  405.                 calendar = (Calendar)GregorianCalendar.GetDefaultInstance().Clone();
  406.                 calendar.SetReadOnlyState(m_isReadOnly);
  407.             }
  408.             else {
  409.                 CultureInfo.CheckDomainSafetyObject(calendar, this);
  410.             }
  411.            
  412.             InitializeOverridableProperties();
  413.         }
  414.        
  415.         [OnSerializing()]
  416.         private void OnSerializing(StreamingContext ctx)
  417.         {
  418.             CultureID = m_cultureTableRecord.CultureID;
  419.             m_useUserOverride = m_cultureTableRecord.UseUserOverride;
  420.             nDataItem = m_cultureTableRecord.EverettDataItem();
  421.            
  422.             //
  423.             // If we have custom culture then we serialize a valid name so it can be used
  424.             // during the deserialization as we cannot use the CultureID at that time.
  425.             //
  426.            
  427.             if (CultureTableRecord.IsCustomCultureId(CultureID)) {
  428.                 // make sure the m_name is initialized.
  429.                 m_name = this.CultureName;
  430.             }
  431.         }
  432.         #endregion Serialization
  433.        
  434.         // Returns a default DateTimeFormatInfo that will be universally
  435.         // supported and constant irrespective of the current culture.
  436.         // Used by FromString methods.
  437.         //
  438.        
  439.         public static DateTimeFormatInfo InvariantInfo {
  440.             get {
  441.                 if (invariantInfo == null) {
  442.                     DateTimeFormatInfo info = new DateTimeFormatInfo();
  443.                     info.Calendar.SetReadOnlyState(true);
  444.                     info.m_isReadOnly = true;
  445.                     invariantInfo = info;
  446.                 }
  447.                 return (invariantInfo);
  448.             }
  449.         }
  450.        
  451.         // Returns the current culture's DateTimeFormatInfo. Used by Parse methods.
  452.         //
  453.        
  454.         public static DateTimeFormatInfo CurrentInfo {
  455.             get {
  456.                 System.Globalization.CultureInfo culture = System.Threading.Thread.CurrentThread.CurrentCulture;
  457.                 if (!culture.m_isInherited) {
  458.                     DateTimeFormatInfo info = culture.dateTimeInfo;
  459.                     if (info != null) {
  460.                         return info;
  461.                     }
  462.                 }
  463.                 return (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
  464.             }
  465.         }
  466.        
  467.        
  468.         public static DateTimeFormatInfo GetInstance(IFormatProvider provider)
  469.         {
  470.             // Fast case for a regular CultureInfo
  471.             DateTimeFormatInfo info;
  472.             CultureInfo cultureProvider = provider as CultureInfo;
  473.             if (cultureProvider != null && !cultureProvider.m_isInherited) {
  474.                 info = cultureProvider.dateTimeInfo;
  475.                 if (info != null) {
  476.                     return info;
  477.                 }
  478.                 else {
  479.                     return cultureProvider.DateTimeFormat;
  480.                 }
  481.             }
  482.             // Fast case for a DTFI;
  483.             info = provider as DateTimeFormatInfo;
  484.             if (info != null) {
  485.                 return info;
  486.             }
  487.             if (provider != null) {
  488.                 info = provider.GetFormat(typeof(DateTimeFormatInfo)) as DateTimeFormatInfo;
  489.                 if (info != null) {
  490.                     return info;
  491.                 }
  492.             }
  493.             return CurrentInfo;
  494.         }
  495.        
  496.        
  497.         public object GetFormat(Type formatType)
  498.         {
  499.             return (formatType == typeof(DateTimeFormatInfo) ? this : null);
  500.         }
  501.        
  502.        
  503.         public object Clone()
  504.         {
  505.             DateTimeFormatInfo n = (DateTimeFormatInfo)MemberwiseClone();
  506.             // We can use the data member calendar in the setter, instead of the property Calendar,
  507.             // since the cloned copy should have the same state as the original copy.
  508.             n.calendar = (Calendar)this.Calendar.Clone();
  509.             n.m_isReadOnly = false;
  510.             return n;
  511.         }
  512.        
  513.        
  514.         public string AMDesignator {
  515.             get {
  516.                 BCLDebug.Assert(amDesignator != null, "DateTimeFormatInfo.AMDesignator, amDesignator != null");
  517.                 return (amDesignator);
  518.             }
  519.            
  520.             set {
  521.                 VerifyWritable();
  522.                 if (value == null) {
  523.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  524.                 }
  525.                 ClearTokenHashTable(true);
  526.                 amDesignator = value;
  527.             }
  528.         }
  529.        
  530.         private void InitializeOverridableProperties()
  531.         {
  532.             // These properties are not affected by calendar settings. And they should be always initialized.
  533.            
  534.             if (amDesignator == null) {
  535.                 amDesignator = m_cultureTableRecord.S1159;
  536.             }
  537.             if (pmDesignator == null) {
  538.                 pmDesignator = m_cultureTableRecord.S2359;
  539.             }
  540.             if (longTimePattern == null) {
  541.                 longTimePattern = m_cultureTableRecord.STIMEFORMAT;
  542.             }
  543.             if (firstDayOfWeek == -1) {
  544.                 firstDayOfWeek = m_cultureTableRecord.IFIRSTDAYOFWEEK;
  545.             }
  546.             if (calendarWeekRule == -1) {
  547.                 calendarWeekRule = m_cultureTableRecord.IFIRSTWEEKOFYEAR;
  548.             }
  549.            
  550.             // These 3 properties are affected by calendar settings.
  551.             if (yearMonthPattern == null) {
  552.                 yearMonthPattern = GetYearMonthPattern(calendar.ID);
  553.             }
  554.             if (shortDatePattern == null) {
  555.                 shortDatePattern = GetShortDatePattern(calendar.ID);
  556.             }
  557.             if (longDatePattern == null) {
  558.                 longDatePattern = GetLongDatePattern(calendar.ID);
  559.             }
  560.         }
  561.        
  562.        
  563.         public Calendar Calendar {
  564.             get {
  565.                 BCLDebug.Assert(calendar != null, "DateTimeFormatInfo.Calendar: calendar != null");
  566.                 return (calendar);
  567.             }
  568.            
  569.             set {
  570.                 VerifyWritable();
  571.                 if (value == null) {
  572.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Obj"));
  573.                 }
  574.                 if (value == calendar) {
  575.                     return;
  576.                 }
  577.                
  578.                 //
  579.                 // Because the culture is agile object which can be attached to a thread and then thread can travel
  580.                 // to another app domain then we prevent attaching any customized object to culture that we cannot contol.
  581.                 //
  582.                 CultureInfo.CheckDomainSafetyObject(value, this);
  583.                
  584.                 for (int i = 0; i < OptionalCalendars.Length; i++) {
  585.                     if (OptionalCalendars[i] == value.ID) {
  586.                         ClearTokenHashTable(false);
  587.                         //
  588.                         // Get the current Win32 user culture.
  589.                         //
  590.                         m_isDefaultCalendar = (value.ID == Calendar.CAL_GREGORIAN);
  591.                         /*
  592.                             When UseUserOverride is TRUE, we should follow the following table
  593.                             to retrieve date/time patterns.
  594.                             CurrentCulture:    Is the culture which creates the DTFI the current user default culture
  595.                                                 specified in the control panel?
  596.                             CurrentCalendar:    Is the specified calendar the current calendar specified in the control panel?
  597.                             n/r: not relavent, don't care.
  598.                             Case    CurrentCulture? CurrentCalendar?    GregorianLocalized? Get Data from
  599.                             ----    --------------- ----------------    ------------------- --------------------------
  600.                             1      Y              Y                  n/r                registry & culture.nlp (for user-overridable data)
  601.                             2      n/r            n/r                Y                  culture.nlp
  602.                             3      n/r            n/r                N                  CALENDAR.nlp*
  603.                         */                       
  604.                        
  605. if (calendar != null) {
  606.                             // clean related properties which are affected by the calendar setting,
  607.                             // so that they will be refreshed when they are accessed next time.
  608.                             //
  609.                            
  610.                             // These properites are in the order as appearing in calendar.xml.
  611.                             m_eraNames = null;
  612.                             m_abbrevEraNames = null;
  613.                             m_abbrevEnglishEraNames = null;
  614.                            
  615.                             shortDatePattern = null;
  616.                             yearMonthPattern = null;
  617.                             monthDayPattern = null;
  618.                             longDatePattern = null;
  619.                            
  620.                             dayNames = null;
  621.                             abbreviatedDayNames = null;
  622.                             m_superShortDayNames = null;
  623.                             monthNames = null;
  624.                             abbreviatedMonthNames = null;
  625.                             genitiveMonthNames = null;
  626.                             m_genitiveAbbreviatedMonthNames = null;
  627.                             leapYearMonthNames = null;
  628.                             formatFlags = DateTimeFormatFlags.NotInitialized;
  629.                            
  630.                             // These properies are not in calendar.xml, but they are dependent on the values like shortDatePattern.
  631.                             fullDateTimePattern = null;
  632.                             generalShortTimePattern = null;
  633.                             generalLongTimePattern = null;
  634.                             allShortDatePatterns = null;
  635.                             allLongDatePatterns = null;
  636.                             allYearMonthPatterns = null;
  637.                            
  638.                            
  639.                         }
  640.                        
  641.                         calendar = value;
  642.                        
  643.                         if (this.m_cultureTableRecord.UseCurrentCalendar(value.ID)) {
  644.                             //
  645.                             // [Case 1]
  646.                             //
  647.                             // If user overriden values are allowed, and the culture is the user default culture
  648.                             // and the specified calendar matches the calendar setting in the control panel,
  649.                             // use data from registry by setting bUseCalendarInfo to be false.
  650.                             //
  651.                             DTFIUserOverrideValues temp = new DTFIUserOverrideValues();
  652.                            
  653.                             // If this is the first time calendar is set, just assign
  654.                             // the value to calendar. We don't have to clean up
  655.                             // related fields.
  656.                             // We need to retrieve all user-override values and cache them to avoid to get different
  657.                             // values between calls to CultureInfo.ClearCachedData()
  658.                             m_cultureTableRecord.GetDTFIOverrideValues(ref temp);
  659.                            
  660.                            
  661.                             amDesignator = temp.amDesignator;
  662.                             pmDesignator = temp.pmDesignator;
  663.                             longTimePattern = temp.longTimePattern;
  664.                             firstDayOfWeek = (int)temp.firstDayOfWeek;
  665.                             calendarWeekRule = (int)temp.calendarWeekRule;
  666.                             shortDatePattern = temp.shortDatePattern;
  667.                             longDatePattern = temp.longDatePattern;
  668.                             yearMonthPattern = temp.yearMonthPattern;
  669.                            
  670.                             // To work around a Win9x data bug. GetLocaleInfo(LOCALE_SYEARMONTH) returns empty string in Win9x.
  671.                             // There is also a NLS bug that GetLocaleInfo returns incorrect YearMonth pattern when the reg key of for YearMonth does not
  672.                             // exists. GetDTFIOVerrideValues() will leave yearMonthPattern to be null in that case.
  673.                            
  674.                             // In these cases, fall back to the table value.
  675.                            
  676.                             if (yearMonthPattern == null || yearMonthPattern.Length == 0) {
  677.                                 yearMonthPattern = GetYearMonthPattern(value.ID);
  678.                             }
  679.                            
  680.                         }
  681.                         else {
  682.                             // Case 2 & Case 3
  683.                            
  684.                             InitializeOverridableProperties();
  685.                         }
  686.                         return;
  687.                     }
  688.                 }
  689.                 // The assigned calendar is not a valid calendar for this culture.
  690.                 throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("Argument_InvalidCalendar"));
  691.             }
  692.         }
  693.        
  694.         internal int[] OptionalCalendars {
  695.             get {
  696.                 if (optionalCalendars == null) {
  697.                     optionalCalendars = this.m_cultureTableRecord.IOPTIONALCALENDARS;
  698.                 }
  699.                 return (optionalCalendars);
  700.             }
  701.         }
  702.        
  703. /*=================================GetEra==========================
  704.         **Action: Get the era value by parsing the name of the era.
  705.         **Returns: The era value for the specified era name.
  706.         **      -1 if the name of the era is not valid or not supported.
  707.         **Arguments: eraName    the name of the era.
  708.         **Exceptions: None.
  709.         ============================================================================*/       
  710.        
  711.        
  712.         public int GetEra(string eraName)
  713.         {
  714.             if (eraName == null) {
  715.                 throw new ArgumentNullException("eraName", Environment.GetResourceString("ArgumentNull_String"));
  716.             }
  717.            
  718.             // The following is based on the assumption that the era value is starting from 1, and has a
  719.             // serial values.
  720.             // If that ever changes, the code has to be changed.
  721.            
  722.             // The calls to String.Compare should use the current culture for the string comparisons, but the
  723.             // invariant culture when comparing against the english names.
  724.             for (int i = 0; i < EraNames.Length; i++) {
  725.                 // Compare the era name in a case-insensitive way.
  726.                 if (m_eraNames[i].Length > 0) {
  727.                     if (String.Compare(eraName, m_eraNames[i], true, CultureInfo.CurrentCulture) == 0) {
  728.                         return (i + 1);
  729.                     }
  730.                 }
  731.             }
  732.             for (int i = 0; i < AbbreviatedEraNames.Length; i++) {
  733.                 if (String.Compare(eraName, m_abbrevEraNames[i], true, CultureInfo.CurrentCulture) == 0) {
  734.                     return (i + 1);
  735.                 }
  736.             }
  737.             for (int i = 0; i < AbbreviatedEnglishEraNames.Length; i++) {
  738.                 // this comparison should use the InvariantCulture. The English name could have linguistically
  739.                 // interesting characters.
  740.                 if (String.Compare(eraName, m_abbrevEnglishEraNames[i], true, CultureInfo.InvariantCulture) == 0) {
  741.                     return (i + 1);
  742.                 }
  743.             }
  744.             return (-1);
  745.         }
  746.        
  747.         internal string[] EraNames {
  748.             get {
  749.                 if (m_eraNames == null) {
  750.                     if (Calendar.ID == Calendar.CAL_GREGORIAN) {
  751.                         // If the calendar is Gregorian localized calendar,
  752.                         // grab the localized name from culture.nlp.
  753.                         m_eraNames = new string[1] {this.m_cultureTableRecord.SADERA};
  754.                     }
  755.                     else if (Calendar.ID != Calendar.CAL_TAIWAN) {
  756.                         // Use Calendar property so that we initialized the calendar when necessary.
  757.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.EraNames] Expected Calendar.ID > 0");
  758.                         m_eraNames = CalendarTable.Default.SERANAMES(Calendar.ID);
  759.                     }
  760.                     else {
  761.                         // Special case for Taiwan calendar.
  762.                         // 0x0404 is the locale ID for Taiwan.
  763.                         m_eraNames = new string[] {CalendarTable.nativeGetEraName(1028, Calendar.ID)};
  764.                     }
  765.                 }
  766.                 return (m_eraNames);
  767.             }
  768.         }
  769.        
  770. /*=================================GetEraName==========================
  771.         **Action: Get the name of the era for the specified era value.
  772.         **Returns: The name of the specified era.
  773.         **Arguments:
  774.         **      era the era value.
  775.         **Exceptions:
  776.         **      ArguementException if the era valie is invalid.
  777.         ============================================================================*/       
  778.        
  779.        
  780.         public string GetEraName(int era)
  781.         {
  782.             if (era == Calendar.CurrentEra) {
  783.                 era = Calendar.CurrentEraValue;
  784.             }
  785.            
  786.             // The following is based on the assumption that the era value is starting from 1, and has a
  787.             // serial values.
  788.             // If that ever changes, the code has to be changed.
  789.             if ((--era) < EraNames.Length && (era >= 0)) {
  790.                 return (m_eraNames[era]);
  791.             }
  792.             throw new ArgumentOutOfRangeException("era", Environment.GetResourceString("ArgumentOutOfRange_InvalidEraValue"));
  793.         }
  794.        
  795.         internal string[] AbbreviatedEraNames {
  796.             get {
  797.                 if (m_abbrevEraNames == null) {
  798.                     if (Calendar.ID == Calendar.CAL_TAIWAN) {
  799.                         string twnEra = GetEraName(1);
  800.                         if (twnEra.Length > 0) {
  801.                             if (twnEra.Length == 4) {
  802.                                 // Windows 2000 & above use 4-character era name.
  803.                                 // Special case for Taiwan because of geo-political issue.
  804.                                 m_abbrevEraNames = new string[] {twnEra.Substring(2, 2)};
  805.                             }
  806.                             else {
  807.                                 // Windows 98/Windows ME use 2-character era name.
  808.                                 m_abbrevEraNames = new string[] {twnEra};
  809.                             }
  810.                         }
  811.                         else {
  812.                             // Return an etmpy string.
  813.                             m_abbrevEraNames = new string[0];
  814.                         }
  815.                     }
  816.                     else {
  817.                         if (Calendar.ID == Calendar.CAL_GREGORIAN) {
  818.                             // If the calendar is Gregorian localized calendar,
  819.                             // grab the localized name from culture.nlp.
  820.                             m_abbrevEraNames = new string[1] {this.m_cultureTableRecord.SABBREVADERA};
  821.                         }
  822.                         else {
  823.                             BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.AbbreviatedEraNames] Expected Calendar.ID > 0");
  824.                             m_abbrevEraNames = CalendarTable.Default.SABBREVERANAMES(Calendar.ID);
  825.                         }
  826.                     }
  827.                 }
  828.                 return (m_abbrevEraNames);
  829.             }
  830.         }
  831.        
  832.        
  833.         public string GetAbbreviatedEraName(int era)
  834.         {
  835.             if (AbbreviatedEraNames.Length == 0) {
  836.                 // If abbreviation era name is not used in this culture,
  837.                 // return the full era name.
  838.                 return (GetEraName(era));
  839.             }
  840.             if (era == Calendar.CurrentEra) {
  841.                 era = Calendar.CurrentEraValue;
  842.             }
  843.             if ((--era) < m_abbrevEraNames.Length && (era >= 0)) {
  844.                 return (m_abbrevEraNames[era]);
  845.             }
  846.             throw new ArgumentOutOfRangeException("era", Environment.GetResourceString("ArgumentOutOfRange_InvalidEraValue"));
  847.         }
  848.        
  849.         internal string[] AbbreviatedEnglishEraNames {
  850.             get {
  851.                 if (m_abbrevEnglishEraNames == null) {
  852.                     BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.AbbreviatedEnglishEraNames] Expected Calendar.ID > 0");
  853.                     m_abbrevEnglishEraNames = CalendarTable.Default.SABBREVENGERANAMES(Calendar.ID);
  854.                 }
  855.                 return (m_abbrevEnglishEraNames);
  856.             }
  857.         }
  858.        
  859.        
  860.         public string DateSeparator {
  861.             get {
  862.                 if (dateSeparator == null) {
  863.                     dateSeparator = this.m_cultureTableRecord.SDATE;
  864.                 }
  865.                 return (dateSeparator);
  866.             }
  867.            
  868.             set {
  869.                 VerifyWritable();
  870.                 if (value == null) {
  871.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  872.                 }
  873.                 ClearTokenHashTable(true);
  874.                 dateSeparator = value;
  875.             }
  876.         }
  877.        
  878.        
  879.         public DayOfWeek FirstDayOfWeek {
  880. // FirstDayOfWeek is always set in the Calendar setter.
  881.             get { return ((DayOfWeek)firstDayOfWeek); }
  882.            
  883.             set {
  884.                 VerifyWritable();
  885.                 if (value >= DayOfWeek.Sunday && value <= DayOfWeek.Saturday) {
  886.                     firstDayOfWeek = (int)value;
  887.                 }
  888.                 else {
  889.                     throw new ArgumentOutOfRangeException("value", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), DayOfWeek.Sunday, DayOfWeek.Saturday));
  890.                 }
  891.             }
  892.         }
  893.        
  894.        
  895.         public CalendarWeekRule CalendarWeekRule {
  896. // CalendarWeekRule is always set in the Calendar setter.
  897.             get { return ((CalendarWeekRule)this.calendarWeekRule); }
  898.            
  899.             set {
  900.                 VerifyWritable();
  901.                 if (value >= CalendarWeekRule.FirstDay && value <= CalendarWeekRule.FirstFourDayWeek) {
  902.                     calendarWeekRule = (int)value;
  903.                 }
  904.                 else {
  905.                     throw new ArgumentOutOfRangeException("value", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek));
  906.                 }
  907.             }
  908.         }
  909.        
  910.        
  911.        
  912.         public string FullDateTimePattern {
  913.             get {
  914.                 if (fullDateTimePattern == null) {
  915.                     fullDateTimePattern = LongDatePattern + " " + LongTimePattern;
  916.                 }
  917.                 return (fullDateTimePattern);
  918.             }
  919.            
  920.             set {
  921.                 VerifyWritable();
  922.                 if (value == null) {
  923.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  924.                 }
  925.                 fullDateTimePattern = value;
  926.             }
  927.         }
  928.        
  929.         private string GetLongDatePattern(int calID)
  930.         {
  931.             string strTemp = String.Empty;
  932.             if (!m_isDefaultCalendar) {
  933.                 // Has to be > 0 or the data'll be null
  934.                 BCLDebug.Assert(calID > 1, "[DateTimeFormatInfo.LongDatePattern] Expected calID > 1");
  935.                 strTemp = CalendarTable.Default.SLONGDATE(calID)[0];
  936.                
  937.                 BCLDebug.Assert(strTemp.Length != 0, "Calendar.nlp should have SLONGDATE value");
  938.             }
  939.             else {
  940.                 strTemp = this.m_cultureTableRecord.SLONGDATE;
  941.             }
  942.             return (strTemp);
  943.         }
  944.        
  945.        
  946.         public string LongDatePattern {
  947.             get {
  948.                 BCLDebug.Assert(longDatePattern != null, "DateTimeFormatInfo.LongDatePattern, longDatePattern != null");
  949.                 return (longDatePattern);
  950.             }
  951.            
  952.             set {
  953.                 VerifyWritable();
  954.                 if (value == null) {
  955.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  956.                 }
  957.                 ClearTokenHashTable(true);
  958.                
  959.                 SetDefaultPatternAsFirstItem(allLongDatePatterns, value);
  960.                 longDatePattern = value;
  961.                 // Clean up cached values that will be affected by this property.
  962.                 fullDateTimePattern = null;
  963.             }
  964.         }
  965.        
  966.        
  967.         public string LongTimePattern {
  968.             get {
  969.                 // LongTimeProperty is always set in the Calendar setter.
  970.                 BCLDebug.Assert(longTimePattern != null, "DateTimeFormatInfo.LongTimePattern, longTimePattern != null");
  971.                 return (longTimePattern);
  972.             }
  973.            
  974.             set {
  975.                 VerifyWritable();
  976.                 if (value == null) {
  977.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  978.                 }
  979.                
  980.                 longTimePattern = value;
  981.                 // Clean up cached values that will be affected by this property.
  982.                 fullDateTimePattern = null;
  983.                 // Full date = long date + long Time
  984.                 generalLongTimePattern = null;
  985.                 // General long date = short date + long Time
  986.             }
  987.         }
  988.        
  989.        
  990.        
  991.         public string MonthDayPattern {
  992.             get {
  993.                 if (monthDayPattern == null) {
  994.                     // strTemp avoids Empty (but not null) string problems in the else.
  995.                     // presumably Empty could be set.
  996.                     string strTemp;
  997.                     if (m_isDefaultCalendar) {
  998.                         strTemp = this.m_cultureTableRecord.SMONTHDAY;
  999.                     }
  1000.                     else {
  1001.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetStringFromTable] Expected Calendar.ID > 0");
  1002.                         strTemp = CalendarTable.Default.SMONTHDAY(Calendar.ID);
  1003.                         // Note that for a tiny bit of time we're not null here, but we're also not necessarily non-empty
  1004.                         if (strTemp.Length == 0)
  1005.                             strTemp = this.m_cultureTableRecord.SMONTHDAY;
  1006.                     }
  1007.                     monthDayPattern = strTemp;
  1008.                 }
  1009.                 return (monthDayPattern);
  1010.             }
  1011.            
  1012.             set {
  1013.                 VerifyWritable();
  1014.                 if (value == null) {
  1015.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  1016.                 }
  1017.                 monthDayPattern = value;
  1018.             }
  1019.         }
  1020.        
  1021.        
  1022.         public string PMDesignator {
  1023.             get {
  1024.                 BCLDebug.Assert(pmDesignator != null, "DateTimeFormatInfo.PMDesignator, pmDesignator != null");
  1025.                 return (pmDesignator);
  1026.             }
  1027.            
  1028.             set {
  1029.                 VerifyWritable();
  1030.                 if (value == null) {
  1031.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  1032.                 }
  1033.                 ClearTokenHashTable(true);
  1034.                 pmDesignator = value;
  1035.             }
  1036.         }
  1037.        
  1038.        
  1039.        
  1040.         public string RFC1123Pattern {
  1041.             get { return (rfc1123Pattern); }
  1042.         }
  1043.        
  1044.         internal string GetShortDatePattern(int calID)
  1045.         {
  1046.             string strTemp = String.Empty;
  1047.             if (!m_isDefaultCalendar) {
  1048.                 // Has to be > 0 or the data'll be null
  1049.                 BCLDebug.Assert(calID > 1, "[DateTimeFormatInfo.ShortDatePattern] Expected calID > 1");
  1050.                 strTemp = CalendarTable.Default.SSHORTDATE(calID)[0];
  1051.                
  1052.                 BCLDebug.Assert(strTemp.Length != 0, "Calendar.nlp should have SHORTDATE value");
  1053.             }
  1054.             else {
  1055.                 strTemp = this.m_cultureTableRecord.SSHORTDATE;
  1056.             }
  1057.             return (strTemp);
  1058.         }
  1059.        
  1060.        
  1061.         public string ShortDatePattern {
  1062.             get {
  1063.                 BCLDebug.Assert(shortDatePattern != null, "DateTimeFormatInfo.ShortDatePattern, shortDatePattern != null");
  1064.                 return (shortDatePattern);
  1065.             }
  1066.            
  1067.             set {
  1068.                 VerifyWritable();
  1069.                 if (value == null) {
  1070.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  1071.                 }
  1072.                
  1073.                 SetDefaultPatternAsFirstItem(allShortDatePatterns, value);
  1074.                 shortDatePattern = value;
  1075.                 // Clean up cached values that will be affected by this property.
  1076.                 generalLongTimePattern = null;
  1077.                 generalShortTimePattern = null;
  1078.             }
  1079.         }
  1080.        
  1081.        
  1082.         public string ShortTimePattern {
  1083.             get {
  1084.                 if (shortTimePattern == null) {
  1085.                     shortTimePattern = this.m_cultureTableRecord.SSHORTTIME;
  1086.                 }
  1087.                 return (shortTimePattern);
  1088.             }
  1089.            
  1090.             set {
  1091.                 VerifyWritable();
  1092.                 if (value == null) {
  1093.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  1094.                 }
  1095.                 shortTimePattern = value;
  1096.                 // Clean up cached values that will be affected by this property.
  1097.                 generalShortTimePattern = null;
  1098.                 // General short date = short date + short time.
  1099.             }
  1100.         }
  1101.        
  1102.        
  1103.         public string SortableDateTimePattern {
  1104.             get { return (sortableDateTimePattern); }
  1105.         }
  1106.        
  1107. /*=================================GeneralShortTimePattern=====================
  1108.         **Property: Return the pattern for 'g' general format: shortDate + short time
  1109.         **Note: This is used by DateTimeFormat.cs to get the pattern for 'g'
  1110.         **      We put this internal property here so that we can avoid doing the
  1111.         **      concatation every time somebody asks for the general format.
  1112.         ==============================================================================*/       
  1113.        
  1114.         internal string GeneralShortTimePattern {
  1115.             get {
  1116.                 if (generalShortTimePattern == null) {
  1117.                     generalShortTimePattern = ShortDatePattern + " " + ShortTimePattern;
  1118.                 }
  1119.                 return (generalShortTimePattern);
  1120.             }
  1121.         }
  1122.        
  1123. /*=================================GeneralLongTimePattern=====================
  1124.         **Property: Return the pattern for 'g' general format: shortDate + Long time
  1125.         **Note: This is used by DateTimeFormat.cs to get the pattern for 'g'
  1126.         **      We put this internal property here so that we can avoid doing the
  1127.         **      concatation every time somebody asks for the general format.
  1128.         ==============================================================================*/       
  1129.        
  1130.         internal string GeneralLongTimePattern {
  1131.             get {
  1132.                 if (generalLongTimePattern == null) {
  1133.                     generalLongTimePattern = ShortDatePattern + " " + LongTimePattern;
  1134.                 }
  1135.                 return (generalLongTimePattern);
  1136.             }
  1137.         }
  1138.        
  1139.        
  1140.         public string TimeSeparator {
  1141.             get {
  1142.                 if (timeSeparator == null) {
  1143.                     timeSeparator = this.m_cultureTableRecord.STIME;
  1144.                 }
  1145.                 return (timeSeparator);
  1146.             }
  1147.            
  1148.             set {
  1149.                 VerifyWritable();
  1150.                 if (value == null) {
  1151.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  1152.                 }
  1153.                 ClearTokenHashTable(true);
  1154.                 timeSeparator = value;
  1155.             }
  1156.         }
  1157.        
  1158.        
  1159.        
  1160.         public string UniversalSortableDateTimePattern {
  1161.             get { return (universalSortableDateTimePattern); }
  1162.         }
  1163.        
  1164.         private string GetYearMonthPattern(int calID)
  1165.         {
  1166.             string result = null;
  1167.             if (!m_isDefaultCalendar) {
  1168.                 // The calendar is the calendar not specified in culture.nlp. Use the calendar table.
  1169.                 // Has to be > 0 or the data'll be null
  1170.                 BCLDebug.Assert(calID > 1, "[DateTimeFormatInfo.YearMonthPattern] Expected calID > 1");
  1171.                 result = CalendarTable.Default.SYEARMONTH(calID)[0];
  1172.                
  1173.                 BCLDebug.Assert(result.Length != 0, "Calendar.nlp should have SYEARMONTH value");
  1174.             }
  1175.             else {
  1176.                 // The calendar is the calendar specified in culture.nlp. Use it.
  1177.                 result = this.m_cultureTableRecord.SYEARMONTHS[0];
  1178.             }
  1179.             return (result);
  1180.            
  1181.         }
  1182.        
  1183.        
  1184.         public string YearMonthPattern {
  1185.             get {
  1186.                 BCLDebug.Assert(yearMonthPattern != null, "DateTimeFormatInfo.YearMonthPattern: yearMonthPattern != null");
  1187.                 return (yearMonthPattern);
  1188.             }
  1189.            
  1190.             set {
  1191.                 VerifyWritable();
  1192.                 if (value == null) {
  1193.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  1194.                 }
  1195.                 yearMonthPattern = value;
  1196.                 SetDefaultPatternAsFirstItem(allYearMonthPatterns, yearMonthPattern);
  1197.             }
  1198.         }
  1199.        
  1200.        
  1201.         //
  1202.         // Check if a string array contains a null value, and throw ArgumentNullException with parameter name "value"
  1203.         //
  1204.         private void CheckNullValue(string[] values, int length)
  1205.         {
  1206.             BCLDebug.Assert(values != null, "value != null");
  1207.             for (int i = 0; i < length; i++) {
  1208.                 if (values[i] == null) {
  1209.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_ArrayValue"));
  1210.                 }
  1211.             }
  1212.         }
  1213.        
  1214.        
  1215.         public string[] AbbreviatedDayNames {
  1216.             get { return ((string[])GetAbbreviatedDayOfWeekNames().Clone()); }
  1217.            
  1218.             set {
  1219.                 VerifyWritable();
  1220.                 if (value == null) {
  1221.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  1222.                 }
  1223.                 if (value.Length != 7) {
  1224.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 7), "value");
  1225.                 }
  1226.                 CheckNullValue(value, value.Length);
  1227.                 ClearTokenHashTable(true);
  1228.                 abbreviatedDayNames = value;
  1229.             }
  1230.         }
  1231.        
  1232.        
  1233.         // Returns the string array of the one-letter day of week names.
  1234.         [System.Runtime.InteropServices.ComVisible(false)]
  1235.         public string[] ShortestDayNames {
  1236.             get { return ((string[])internalGetSuperShortDayNames().Clone()); }
  1237.            
  1238.             set {
  1239.                 VerifyWritable();
  1240.                 if (value == null) {
  1241.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  1242.                 }
  1243.                 if (value.Length != 7) {
  1244.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 7), "value");
  1245.                 }
  1246.                 CheckNullValue(value, value.Length);
  1247.                 this.m_superShortDayNames = value;
  1248.             }
  1249.         }
  1250.        
  1251.        
  1252.         public string[] DayNames {
  1253.             get { return ((string[])GetDayOfWeekNames().Clone()); }
  1254.            
  1255.             set {
  1256.                 VerifyWritable();
  1257.                 if (value == null) {
  1258.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  1259.                 }
  1260.                 if (value.Length != 7) {
  1261.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 7), "value");
  1262.                 }
  1263.                 CheckNullValue(value, value.Length);
  1264.                 ClearTokenHashTable(true);
  1265.                 dayNames = value;
  1266.             }
  1267.         }
  1268.        
  1269.        
  1270.         public string[] AbbreviatedMonthNames {
  1271.             get { return ((string[])GetAbbreviatedMonthNames().Clone()); }
  1272.            
  1273.             set {
  1274.                 VerifyWritable();
  1275.                 if (value == null) {
  1276.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  1277.                 }
  1278.                 if (value.Length != 13) {
  1279.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 13), "value");
  1280.                 }
  1281.                 CheckNullValue(value, value.Length - 1);
  1282.                 ClearTokenHashTable(true);
  1283.                 abbreviatedMonthNames = value;
  1284.             }
  1285.         }
  1286.        
  1287.        
  1288.         public string[] MonthNames {
  1289.             get { return ((string[])GetMonthNames().Clone()); }
  1290.            
  1291.             set {
  1292.                 VerifyWritable();
  1293.                 if (value == null) {
  1294.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  1295.                 }
  1296.                 if (value.Length != 13) {
  1297.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 13), "value");
  1298.                 }
  1299.                 CheckNullValue(value, value.Length - 1);
  1300.                 monthNames = value;
  1301.                 ClearTokenHashTable(true);
  1302.             }
  1303.         }
  1304.        
  1305.         // Whitespaces that we allow in the month names.
  1306.         // U+00a0 is non-breaking space.
  1307.         static char[] MonthSpaces = {' ', ' '};
  1308.        
  1309.         internal bool HasSpacesInMonthNames {
  1310.             get { return (FormatFlags & DateTimeFormatFlags.UseSpacesInMonthNames) != 0; }
  1311.         }
  1312.        
  1313.         internal bool HasSpacesInDayNames {
  1314.             get { return (FormatFlags & DateTimeFormatFlags.UseSpacesInDayNames) != 0; }
  1315.         }
  1316.        
  1317.        
  1318.         //
  1319.         // internalGetMonthName
  1320.         //
  1321.         // Actions: Return the month name using the specified MonthNameStyles in either abbreviated form
  1322.         // or full form.
  1323.         // Arguments:
  1324.         // month
  1325.         // style To indicate a form like regular/genitive/month name in a leap year.
  1326.         // abbreviated When true, return abbreviated form. Otherwise, return a full form.
  1327.         // Exceptions:
  1328.         // ArgumentOutOfRangeException When month name is invalid.
  1329.         //
  1330.         internal string internalGetMonthName(int month, MonthNameStyles style, bool abbreviated)
  1331.         {
  1332.             //
  1333.             // Right now, style is mutual exclusive, but I make the style to be flag so that
  1334.             // maybe we can combine flag if there is such a need.
  1335.             //
  1336.             string[] monthNamesArray = null;
  1337.             switch (style) {
  1338.                 case MonthNameStyles.Genitive:
  1339.                     monthNamesArray = internalGetGenitiveMonthNames(abbreviated);
  1340.                     break;
  1341.                 case MonthNameStyles.LeapYear:
  1342.                         /*abbreviated*/                    monthNamesArray = internalGetLeapYearMonthNames();
  1343.                     break;
  1344.                 default:
  1345.                     monthNamesArray = (abbreviated ? GetAbbreviatedMonthNames() : GetMonthNames());
  1346.                     break;
  1347.             }
  1348.             // The month range is from 1 ~ this.m_monthNames.Length
  1349.             // (actually is 13 right now for all cases)
  1350.             if ((month < 1) || (month > monthNamesArray.Length)) {
  1351.                 throw new ArgumentOutOfRangeException("month", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), 1, monthNamesArray.Length));
  1352.             }
  1353.             return (monthNamesArray[month - 1]);
  1354.         }
  1355.        
  1356.         //
  1357.         // internalGetGenitiveMonthNames
  1358.         //
  1359.         // Action: Retrieve the array which contains the month names in genitive form.
  1360.         // If this culture does not use the gentive form, the normal month name is returned.
  1361.         // Arguments:
  1362.         // abbreviated When true, return abbreviated form. Otherwise, return a full form.
  1363.         //
  1364.         private string[] internalGetGenitiveMonthNames(bool abbreviated)
  1365.         {
  1366.             if (abbreviated) {
  1367.                 if (this.m_genitiveAbbreviatedMonthNames == null) {
  1368.                     if (m_isDefaultCalendar) {
  1369.                         // Only Gregorian localized calendar can have genitive form.
  1370.                         string[] temp = this.m_cultureTableRecord.SABBREVMONTHGENITIVENAMES;
  1371.                         if (temp.Length > 0) {
  1372.                             // Genitive form exists.
  1373.                             this.m_genitiveAbbreviatedMonthNames = temp;
  1374.                         }
  1375.                         else {
  1376.                             // Genitive form does not exist. Use the regular month names.
  1377.                             this.m_genitiveAbbreviatedMonthNames = GetAbbreviatedMonthNames();
  1378.                         }
  1379.                     }
  1380.                     else {
  1381.                         this.m_genitiveAbbreviatedMonthNames = GetAbbreviatedMonthNames();
  1382.                     }
  1383.                     BCLDebug.Assert(this.m_genitiveAbbreviatedMonthNames.Length == 13, "[DateTimeFormatInfo.GetGenitiveMonthNames] Expected 13 abbreviated genitive month names in a year");
  1384.                 }
  1385.                 return (this.m_genitiveAbbreviatedMonthNames);
  1386.             }
  1387.            
  1388.             if (genitiveMonthNames == null) {
  1389.                 if (m_isDefaultCalendar) {
  1390.                     // Only Gregorian localized calendar can have genitive form.
  1391.                     string[] temp = this.m_cultureTableRecord.SMONTHGENITIVENAMES;
  1392.                     if (temp.Length > 0) {
  1393.                         // Genitive form exists.
  1394.                         genitiveMonthNames = temp;
  1395.                     }
  1396.                     else {
  1397.                         // Genitive form does not exist. Use the regular month names.
  1398.                         genitiveMonthNames = GetMonthNames();
  1399.                     }
  1400.                 }
  1401.                 else {
  1402.                     genitiveMonthNames = GetMonthNames();
  1403.                 }
  1404.                 BCLDebug.Assert(genitiveMonthNames.Length == 13, "[DateTimeFormatInfo.GetGenitiveMonthNames] Expected 13 genitive month names in a year");
  1405.             }
  1406.             return (genitiveMonthNames);
  1407.         }
  1408.        
  1409.         //
  1410.         // internalGetLeapYearMonthNames
  1411.         //
  1412.         // Actions: Retrieve the month names used in a leap year.
  1413.         // If this culture does not have different month names in a leap year, the normal month name is returned.
  1414.         // Agruments: None. (can use abbreviated later if needed)
  1415.         //
  1416.         internal string[] internalGetLeapYearMonthNames()/*bool abbreviated*/
  1417.         {
  1418.             if (leapYearMonthNames == null) {
  1419.                 if (m_isDefaultCalendar) {
  1420.                     //
  1421.                     // If this is a Gregorian localized calendar, there is no differences between the month names in a regular year
  1422.                     // and those in a leap year. Just return the regular month names.
  1423.                     //
  1424.                     leapYearMonthNames = GetMonthNames();
  1425.                 }
  1426.                 else {
  1427.                     BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.internalGetLeapYearMonthNames] Expected Calendar.ID > 0");
  1428.                     string[] temp = CalendarTable.Default.SLEAPYEARMONTHNAMES(Calendar.ID);
  1429.                     if (temp.Length > 0) {
  1430.                         leapYearMonthNames = temp;
  1431.                     }
  1432.                     else {
  1433.                         leapYearMonthNames = GetMonthNames();
  1434.                     }
  1435.                 }
  1436.             }
  1437.             return (leapYearMonthNames);
  1438.         }
  1439.        
  1440.        
  1441.         public string GetAbbreviatedDayName(DayOfWeek dayofweek)
  1442.         {
  1443.            
  1444.             if ((int)dayofweek < 0 || (int)dayofweek > 6) {
  1445.                 throw new ArgumentOutOfRangeException("dayofweek", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), DayOfWeek.Sunday, DayOfWeek.Saturday));
  1446.             }
  1447.             //
  1448.             // Don't call the public property AbbreviatedDayNames here since a clone is needed in that
  1449.             // property, so it will be slower. Instead, use GetAbbreviatedDayOfWeekNames() directly.
  1450.             //
  1451.             return (GetAbbreviatedDayOfWeekNames()[(int)dayofweek]);
  1452.         }
  1453.        
  1454.         // Returns the super short day of week names for the specified day of week.
  1455.        
  1456.         [System.Runtime.InteropServices.ComVisible(false)]
  1457.         public string GetShortestDayName(DayOfWeek dayOfWeek)
  1458.         {
  1459.            
  1460.             if ((int)dayOfWeek < 0 || (int)dayOfWeek > 6) {
  1461.                 throw new ArgumentOutOfRangeException("dayOfWeek", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), DayOfWeek.Sunday, DayOfWeek.Saturday));
  1462.             }
  1463.             //
  1464.             // Don't call the public property SuperShortDayNames here since a clone is needed in that
  1465.             // property, so it will be slower. Instead, use internalGetSuperShortDayNames() directly.
  1466.             //
  1467.             return (internalGetSuperShortDayNames()[(int)dayOfWeek]);
  1468.         }
  1469.        
  1470.        
  1471.         internal string[] GetCombinedPatterns(string[] patterns1, string[] patterns2, string connectString)
  1472.         {
  1473.             string[] result = new string[patterns1.Length * patterns2.Length];
  1474.             for (int i = 0; i < patterns1.Length; i++) {
  1475.                 for (int j = 0; j < patterns2.Length; j++) {
  1476.                     result[i * patterns2.Length + j] = patterns1[i] + connectString + patterns2[j];
  1477.                 }
  1478.             }
  1479.             return (result);
  1480.         }
  1481.        
  1482.        
  1483.         public string[] GetAllDateTimePatterns()
  1484.         {
  1485.             ArrayList results = new ArrayList(DEFAULT_ALL_DATETIMES_SIZE);
  1486.            
  1487.             for (int i = 0; i < DateTimeFormat.allStandardFormats.Length; i++) {
  1488.                 string[] strings = GetAllDateTimePatterns(DateTimeFormat.allStandardFormats[i]);
  1489.                 for (int j = 0; j < strings.Length; j++) {
  1490.                     results.Add(strings[j]);
  1491.                 }
  1492.             }
  1493.             string[] value = new string[results.Count];
  1494.             results.CopyTo(0, value, 0, results.Count);
  1495.             return (value);
  1496.         }
  1497.        
  1498.        
  1499.         public string[] GetAllDateTimePatterns(char format)
  1500.         {
  1501.             string[] result = null;
  1502.            
  1503.             switch (format) {
  1504.                 case 'd':
  1505.                     result = ClonedAllShortDatePatterns;
  1506.                     break;
  1507.                 case 'D':
  1508.                     result = ClonedAllLongDatePatterns;
  1509.                     break;
  1510.                 case 'f':
  1511.                     result = GetCombinedPatterns(ClonedAllLongDatePatterns, ClonedAllShortTimePatterns, " ");
  1512.                     break;
  1513.                 case 'F':
  1514.                     result = GetCombinedPatterns(ClonedAllLongDatePatterns, ClonedAllLongTimePatterns, " ");
  1515.                     break;
  1516.                 case 'g':
  1517.                     result = GetCombinedPatterns(ClonedAllShortDatePatterns, ClonedAllShortTimePatterns, " ");
  1518.                     break;
  1519.                 case 'G':
  1520.                     result = GetCombinedPatterns(ClonedAllShortDatePatterns, ClonedAllLongTimePatterns, " ");
  1521.                     break;
  1522.                 case 'm':
  1523.                 case 'M':
  1524.                     result = new string[] {MonthDayPattern};
  1525.                     break;
  1526.                 case 'o':
  1527.                 case 'O':
  1528.                     result = new string[] {DateTimeFormat.RoundtripFormat};
  1529.                     break;
  1530.                 case 'r':
  1531.                 case 'R':
  1532.                     result = new string[] {rfc1123Pattern};
  1533.                     break;
  1534.                 case 's':
  1535.                     result = new string[] {sortableDateTimePattern};
  1536.                     break;
  1537.                 case 't':
  1538.                     result = ClonedAllShortTimePatterns;
  1539.                     break;
  1540.                 case 'T':
  1541.                     result = ClonedAllLongTimePatterns;
  1542.                     break;
  1543.                 case 'u':
  1544.                     result = new string[] {UniversalSortableDateTimePattern};
  1545.                     break;
  1546.                 case 'U':
  1547.                     result = GetCombinedPatterns(ClonedAllLongDatePatterns, ClonedAllLongTimePatterns, " ");
  1548.                     break;
  1549.                 case 'y':
  1550.                 case 'Y':
  1551.                     result = ClonedAllYearMonthPatterns;
  1552.                     break;
  1553.                 default:
  1554.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadFormatSpecifier"), "format");
  1555.                     break;
  1556.             }
  1557.             return (result);
  1558.         }
  1559.        
  1560.        
  1561.         public string GetDayName(DayOfWeek dayofweek)
  1562.         {
  1563.             if ((int)dayofweek < 0 || (int)dayofweek > 6) {
  1564.                 throw new ArgumentOutOfRangeException("dayofweek", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), DayOfWeek.Sunday, DayOfWeek.Saturday));
  1565.             }
  1566.            
  1567.             return (GetDayOfWeekNames()[(int)dayofweek]);
  1568.         }
  1569.        
  1570.        
  1571.        
  1572.         public string GetAbbreviatedMonthName(int month)
  1573.         {
  1574.             if (month < 1 || month > 13) {
  1575.                 throw new ArgumentOutOfRangeException("month", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), 1, 13));
  1576.             }
  1577.             return (GetAbbreviatedMonthNames()[month - 1]);
  1578.         }
  1579.        
  1580.        
  1581.         public string GetMonthName(int month)
  1582.         {
  1583.             if (month < 1 || month > 13) {
  1584.                 throw new ArgumentOutOfRangeException("month", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), 1, 13));
  1585.             }
  1586.             return (GetMonthNames()[month - 1]);
  1587.         }
  1588.        
  1589.        
  1590.        
  1591.         internal string[] ClonedAllYearMonthPatterns {
  1592.             get {
  1593.                 if (allYearMonthPatterns == null) {
  1594.                     string[] temp = null;
  1595.                    
  1596.                     if (!m_isDefaultCalendar) {
  1597.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.AllYearMonthPatternsNeedClone] Expected Calendar.ID > 0");
  1598.                        
  1599.                         temp = CalendarTable.Default.SYEARMONTH(Calendar.ID);
  1600.                        
  1601.                         // In the data table, some calendars store null for long date pattern.
  1602.                         // This means that we have to use the default format of the user culture for that calendar.
  1603.                         // So, get the pattern from culture.
  1604.                         if (temp == null) {
  1605.                             temp = this.m_cultureTableRecord.SYEARMONTHS;
  1606.                         }
  1607.                     }
  1608.                     else {
  1609.                         temp = this.m_cultureTableRecord.SYEARMONTHS;
  1610.                     }
  1611.                    
  1612.                     System.Threading.Thread.MemoryBarrier();
  1613.                     SetDefaultPatternAsFirstItem(temp, YearMonthPattern);
  1614.                     allYearMonthPatterns = temp;
  1615.                 }
  1616.                
  1617.                 if (allYearMonthPatterns[0].Equals(YearMonthPattern)) {
  1618.                     return (string[])allYearMonthPatterns.Clone();
  1619.                 }
  1620.                
  1621.                 return AddDefaultFormat(allYearMonthPatterns, YearMonthPattern);
  1622.             }
  1623.         }
  1624.        
  1625.        
  1626.         // NOTE: Clone this string array if you want to return it to user. Otherwise, you are returnning a writable cache copy.
  1627.         internal string[] ClonedAllShortDatePatterns {
  1628.             get {
  1629.                 if (allShortDatePatterns == null) {
  1630.                     string[] temp = null;
  1631.                     if (!m_isDefaultCalendar) {
  1632.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.AllShortDatePatternsNeedClone] Expected Calendar.ID > 0");
  1633.                         temp = CalendarTable.Default.SSHORTDATE(Calendar.ID);
  1634.                         // In the data table, some calendars store null for long date pattern.
  1635.                         // This means that we have to use the default format of the user culture for that calendar.
  1636.                         // So, get the pattern from culture.
  1637.                         if (temp == null) {
  1638.                             temp = this.m_cultureTableRecord.SSHORTDATES;
  1639.                         }
  1640.                     }
  1641.                     else {
  1642.                         temp = this.m_cultureTableRecord.SSHORTDATES;
  1643.                     }
  1644.                     System.Threading.Thread.MemoryBarrier();
  1645.                     SetDefaultPatternAsFirstItem(temp, ShortDatePattern);
  1646.                     allShortDatePatterns = temp;
  1647.                 }
  1648.                
  1649.                 if (allShortDatePatterns[0].Equals(ShortDatePattern)) {
  1650.                     return (string[])allShortDatePatterns.Clone();
  1651.                 }
  1652.                
  1653.                 return (AddDefaultFormat(allShortDatePatterns, ShortDatePattern));
  1654.             }
  1655.         }
  1656.        
  1657.         // NOTE: Clone this string array if you want to return it to user. Otherwise, you are returnning a writable cache copy.
  1658.         internal string[] ClonedAllLongDatePatterns {
  1659.             get {
  1660.                 if (allLongDatePatterns == null) {
  1661.                     string[] temp = null;
  1662.                     if (!m_isDefaultCalendar) {
  1663.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.AllLongDatePatternsNeedClone] Expected Calendar.ID > 0");
  1664.                         temp = CalendarTable.Default.SLONGDATE(Calendar.ID);
  1665.                         // In the data table, some calendars store null for long date pattern.
  1666.                         // This means that we have to use the default format of the user culture for that calendar.
  1667.                         // So, get the pattern from culture.
  1668.                         if (temp == null) {
  1669.                             temp = this.m_cultureTableRecord.SLONGDATES;
  1670.                         }
  1671.                     }
  1672.                     else {
  1673.                         temp = this.m_cultureTableRecord.SLONGDATES;
  1674.                     }
  1675.                     System.Threading.Thread.MemoryBarrier();
  1676.                     SetDefaultPatternAsFirstItem(temp, LongDatePattern);
  1677.                     allLongDatePatterns = temp;
  1678.                 }
  1679.                
  1680.                 if (allLongDatePatterns[0].Equals(LongDatePattern)) {
  1681.                     return (string[])allLongDatePatterns.Clone();
  1682.                 }
  1683.                
  1684.                 return (AddDefaultFormat(allLongDatePatterns, LongDatePattern));
  1685.             }
  1686.         }
  1687.        
  1688.         internal void SetDefaultPatternAsFirstItem(string[] patterns, string defaultPattern)
  1689.         {
  1690.             if (patterns == null) {
  1691.                 return;
  1692.             }
  1693.            
  1694.             for (int i = 0; i < patterns.Length; i++) {
  1695.                 if (patterns[i].Equals(defaultPattern)) {
  1696.                     if (i != 0) {
  1697.                         // default date is already exist in the list. set it as first item in the list.
  1698.                         string temp = patterns[i];
  1699.                        
  1700.                         for (int j = i; j > 0; j--) {
  1701.                             patterns[j] = patterns[j - 1];
  1702.                         }
  1703.                        
  1704.                         patterns[0] = temp;
  1705.                     }
  1706.                    
  1707.                     return;
  1708.                 }
  1709.             }
  1710.         }
  1711.        
  1712.         ////////////////////////////////////////////////////////////////////////
  1713.         //
  1714.         // The default LongDatePattern is not in the standard list. Add it as the first item.
  1715.         //
  1716.         ////////////////////////////////////////////////////////////////////////
  1717.        
  1718.         internal string[] AddDefaultFormat(string[] datePatterns, string defaultDateFormat)
  1719.         {
  1720.             string[] updatedPatterns = new string[datePatterns.Length + 1];
  1721.             updatedPatterns[0] = defaultDateFormat;
  1722.             Array.Copy(datePatterns, 0, updatedPatterns, 1, datePatterns.Length);
  1723.             // We need to scan the non-standard longDatePattern.
  1724.             m_scanDateWords = true;
  1725.             return updatedPatterns;
  1726.         }
  1727.        
  1728.         // NOTE: Clone this string array if you want to return it to user. Otherwise, you are returnning a writable cache copy.
  1729.         internal string[] ClonedAllShortTimePatterns {
  1730.             get {
  1731.                 if (allShortTimePatterns == null) {
  1732.                     allShortTimePatterns = this.m_cultureTableRecord.SSHORTTIMES;
  1733.                     SetDefaultPatternAsFirstItem(allShortTimePatterns, ShortTimePattern);
  1734.                 }
  1735.                
  1736.                 if (allShortTimePatterns[0].Equals(ShortTimePattern)) {
  1737.                     return (string[])allShortTimePatterns.Clone();
  1738.                 }
  1739.                
  1740.                 return (AddDefaultFormat(allShortTimePatterns, ShortTimePattern));
  1741.             }
  1742.         }
  1743.        
  1744.         internal string[] ClonedAllLongTimePatterns {
  1745.             get {
  1746.                 if (allLongTimePatterns == null) {
  1747.                     allLongTimePatterns = this.m_cultureTableRecord.STIMEFORMATS;
  1748.                     SetDefaultPatternAsFirstItem(allLongTimePatterns, LongTimePattern);
  1749.                 }
  1750.                 if (allLongTimePatterns[0].Equals(LongTimePattern)) {
  1751.                     return (string[])allLongTimePatterns.Clone();
  1752.                 }
  1753.                
  1754.                 return (AddDefaultFormat(allLongTimePatterns, LongTimePattern));
  1755.             }
  1756.         }
  1757.        
  1758.         //
  1759.         // The known word used in date pattern for this culture. E.g. Spanish cultures often
  1760.         // have 'de' in their long date pattern.
  1761.         // This is used by DateTime.Parse() to decide if a word should be ignored or not.
  1762.         //
  1763.         internal string[] DateWords {
  1764.             get {
  1765.                 if (m_dateWords == null) {
  1766.                     m_dateWords = this.m_cultureTableRecord.SDATEWORDS;
  1767.                 }
  1768.                
  1769.                 return (m_dateWords);
  1770.             }
  1771.         }
  1772.        
  1773.        
  1774.         public static DateTimeFormatInfo ReadOnly(DateTimeFormatInfo dtfi)
  1775.         {
  1776.             if (dtfi == null) {
  1777.                 throw new ArgumentNullException("dtfi", Environment.GetResourceString("ArgumentNull_Obj"));
  1778.             }
  1779.             if (dtfi.IsReadOnly) {
  1780.                 return (dtfi);
  1781.             }
  1782.             DateTimeFormatInfo info = (DateTimeFormatInfo)(dtfi.MemberwiseClone());
  1783.             info.Calendar = Calendar.ReadOnly(info.Calendar);
  1784.             info.m_isReadOnly = true;
  1785.             return (info);
  1786.         }
  1787.        
  1788.        
  1789.         public bool IsReadOnly {
  1790.             get { return (m_isReadOnly); }
  1791.         }
  1792.        
  1793.         private static int CalendarIdToCultureId(int calendarId)
  1794.         {
  1795.             switch (calendarId) {
  1796.                 case Calendar.CAL_GREGORIAN_US:
  1797.                     return 1065;
  1798.                 case Calendar.CAL_JAPAN:
  1799.                     // "fa-IR" Iran
  1800.                     return 1041;
  1801.                 case Calendar.CAL_TAIWAN:
  1802.                     // "ja-JP" Japan
  1803.                     return 1028;
  1804.                 case Calendar.CAL_KOREA:
  1805.                     // zh-TW Taiwan
  1806.                     return 1042;
  1807.                 case Calendar.CAL_HIJRI:
  1808.                 case Calendar.CAL_GREGORIAN_ARABIC:
  1809.                 case Calendar.CAL_UMALQURA:
  1810.                     // "ko-KR" Korea
  1811.                     return 1025;
  1812.                 case Calendar.CAL_THAI:
  1813.                     // "ar-SA" Saudi Arabia
  1814.                     return 1054;
  1815.                 case Calendar.CAL_HEBREW:
  1816.                     // "th-TH" Thailand
  1817.                     return 1037;
  1818.                 case Calendar.CAL_GREGORIAN_ME_FRENCH:
  1819.                     // "he-IL" Israel
  1820.                     return 5121;
  1821.                 case Calendar.CAL_GREGORIAN_XLIT_ENGLISH:
  1822.                 case Calendar.CAL_GREGORIAN_XLIT_FRENCH:
  1823.                     // "ar-DZ" Algeria
  1824.                     return 2049;
  1825.                 default:
  1826.                     // "ar-IQ"; Iraq
  1827.                     BCLDebug.Assert(false, "[DateTimeFormatInfo.CalendarIdToCultureId] we shouldn't come here.");
  1828.                     break;
  1829.             }
  1830.            
  1831.             return 0;
  1832.         }
  1833.        
  1834.         //
  1835.         // GetCalendarNativeNameFallback is used when we got empty string native calendar name from the culture data
  1836.         // in the case of the custom cultures.
  1837.         // GetCalendarNativeNameFallback is getting the name from the framework data from some specific cultures
  1838.         // for example to get the native name for Hijri calendar we use ar-SA culture to get that name.
  1839.         //
  1840.         private string GetCalendarNativeNameFallback(int calendarId)
  1841.         {
  1842.             BCLDebug.Assert(calendarId != Calendar.CAL_GREGORIAN, "[DateTimeFormatInfo.GetCalendarNativeNameFallback] Unexpected Gregorian localized calendar.");
  1843.            
  1844.             if (m_calendarNativeNames == null) {
  1845.                 lock (InternalSyncObject) {
  1846.                     if (m_calendarNativeNames == null)
  1847.                         m_calendarNativeNames = new Hashtable();
  1848.                 }
  1849.             }
  1850.            
  1851.             BCLDebug.Assert(m_calendarNativeNames != null, "[DateTimeFormatInfo.GetCalendarNativeNameFallback] m_calendarNativeNames should be valid");
  1852.            
  1853.             string temp = (string)m_calendarNativeNames[calendarId];
  1854.             if (temp != null)
  1855.                 return temp;
  1856.            
  1857.             string name = String.Empty;
  1858.            
  1859.             int cultureId = CalendarIdToCultureId(calendarId);
  1860.            
  1861.             if (cultureId != 0) {
  1862.                 string[] values = new CultureTableRecord(cultureId, false).SNATIVECALNAMES;
  1863.                
  1864.                 BCLDebug.Assert(calendar.ID >= 1, "[DateTimeFormatInfo.GetCalendarNativeNameFallback] calendar.ID >= 1");
  1865.                
  1866.                 int id = calendar.ID - 1;
  1867.                
  1868.                 // The element 0 stored the name for calendar ID 1 (since there is no calendar ID 0)
  1869.                 if (id < values.Length) {
  1870.                     // If U+FEFF is stored, it means that no information for that calendar is available.
  1871.                     if (values[id].Length > 0 && values[id][0] != '')
  1872.                         name = values[id];
  1873.                 }
  1874.             }
  1875.            
  1876.             lock (InternalSyncObject) {
  1877.                 if (m_calendarNativeNames[calendarId] == null)
  1878.                     m_calendarNativeNames[calendarId] = name;
  1879.             }
  1880.            
  1881.             return name;
  1882.         }
  1883.        
  1884.         // Return the native name for the calendar in DTFI.Calendar. The native name is referred to
  1885.         // the culture used to create the DTFI. E.g. in the following example, the native language is Japanese.
  1886.         // DateTimeFormatInfo dtfi = new CutlureInfo("ja-JP", false).DateTimeFormat.Calendar = new JapaneseCalendar();
  1887.         // String nativeName = dtfi.NativeCalendarName; // Get the Japanese name for the Japanese calendar.
  1888.         // DateTimeFormatInfo dtfi = new CutlureInfo("ja-JP", false).DateTimeFormat.Calendar = new GregorianCalendar(GregorianCalendarTypes.Localized);
  1889.         // String nativeName = dtfi.NativeCalendarName; // Get the Japanese name for the Gregorian calendar.
  1890.        
  1891.        
  1892.         [System.Runtime.InteropServices.ComVisible(false)]
  1893.         public string NativeCalendarName {
  1894.             get {
  1895.                
  1896.                 if (Calendar.ID == Calendar.CAL_TAIWAN) {
  1897.                     //
  1898.                     // Specail case for Taiwan calenadr.
  1899.                     //
  1900.                    
  1901.                     // In non-Taiwan machine, the following call will return null.
  1902.                     // 0x0404 is the locale ID for Taiwan.
  1903.                     string result = GetCalendarInfo(1028, Calendar.CAL_TAIWAN, CAL_SCALNAME);
  1904.                     if (result == null) {
  1905.                         // 0x0404 is the locale ID for Taiwan.
  1906.                         // In Win9x, the Win32 GetCalendarInfo() does not support CAL_SCALNAME. In that case,
  1907.                         // fallback to use the era name.
  1908.                         result = CalendarTable.nativeGetEraName(1028, Calendar.CAL_TAIWAN);
  1909.                         if (result == null) {
  1910.                             // In non-CHT platform, the previous two Win32 calls will fail. Just return an empty string.
  1911.                             result = String.Empty;
  1912.                         }
  1913.                     }
  1914.                     return (result);
  1915.                 }
  1916.                 else {
  1917.                     string[] values = this.m_cultureTableRecord.SNATIVECALNAMES;
  1918.                     BCLDebug.Assert(calendar.ID >= 1, "calendar.ID >= 1");
  1919.                     int id = calendar.ID - 1;
  1920.                     // The element 0 stored the name for calendar ID 1 (since there is no calendar ID 0)
  1921.                     if (id < values.Length) {
  1922.                         if (values[id].Length > 0) {
  1923.                             // If U+FEFF is stored, it means that no information for that calendar is available.
  1924.                             if (values[id][0] != '')
  1925.                                 return (values[id]);
  1926.                         }
  1927.                         else {
  1928.                             //
  1929.                             // Empty string means we have custom culture. Then try the fallback.
  1930.                             //
  1931.                             BCLDebug.Assert(this.m_cultureTableRecord.IsCustomCulture, "[DateTimeFormatInfo.NativeCalendarName] Expected custom culture");
  1932.                             return GetCalendarNativeNameFallback(calendar.ID);
  1933.                         }
  1934.                     }
  1935.                 }
  1936.                 // If data is not available, just return an empty string.
  1937.                 return (String.Empty);
  1938.             }
  1939.         }
  1940.        
  1941.         //
  1942.         // Used by custom cultures and others to set the list of available formats. Note that none of them are
  1943.         // explicitly used unless someone calls GetAllDateTimePatterns and subsequently uses one of the items
  1944.         // from the list.
  1945.         //
  1946.         // Most of the format characters that can be used in GetAllDateTimePatterns are
  1947.         // not really needed since they are one of the following:
  1948.         //
  1949.         // r/R/s/u locale-independent constants -- cannot be changed!
  1950.         // m/M/y/Y fields with a single string in them -- that can be set through props directly
  1951.         // f/F/g/G/U derived fields based on combinations of various of the below formats
  1952.         //
  1953.         // NOTE: No special validation is done here beyond what is done when the actual respective fields
  1954.         // are used (what would be the point of disallowing here what we allow in the appropriate property?)
  1955.         //
  1956.         // WARNING: If more validation is ever done in one place, it should be done in the other.
  1957.         //
  1958.        
  1959.         [System.Runtime.InteropServices.ComVisible(false)]
  1960.         public void SetAllDateTimePatterns(string[] patterns, char format)
  1961.         {
  1962.             VerifyWritable();
  1963.             if (patterns == null) {
  1964.                 throw new ArgumentNullException("patterns", Environment.GetResourceString("ArgumentNull_Array"));
  1965.             }
  1966.            
  1967.             if (patterns.Length == 0) {
  1968.                 throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError"), "patterns");
  1969.             }
  1970.            
  1971.             for (int i = 0; i < patterns.Length; i++) {
  1972.                 if (patterns[i] == null) {
  1973.                     throw new ArgumentNullException(Environment.GetResourceString("ArgumentNull_ArrayValue"));
  1974.                 }
  1975.             }
  1976.            
  1977.             switch (format) {
  1978.                 case 'd':
  1979.                     ShortDatePattern = patterns[0];
  1980.                     this.allShortDatePatterns = patterns;
  1981.                     break;
  1982.                 case 'D':
  1983.                    
  1984.                     LongDatePattern = patterns[0];
  1985.                     this.allLongDatePatterns = patterns;
  1986.                     break;
  1987.                 case 't':
  1988.                    
  1989.                     ShortTimePattern = patterns[0];
  1990.                     this.allShortTimePatterns = patterns;
  1991.                     break;
  1992.                 case 'T':
  1993.                    
  1994.                     LongTimePattern = patterns[0];
  1995.                     this.allLongTimePatterns = patterns;
  1996.                     break;
  1997.                 case 'y':
  1998.                 case 'Y':
  1999.                    
  2000.                     yearMonthPattern = patterns[0];
  2001.                     this.allYearMonthPatterns = patterns;
  2002.                     break;
  2003.                 default:
  2004.                    
  2005.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadFormatSpecifier"), "format");
  2006.                     break;
  2007.             }
  2008.             return;
  2009.         }
  2010.        
  2011.         [System.Runtime.InteropServices.ComVisible(false)]
  2012.         public string[] AbbreviatedMonthGenitiveNames {
  2013.             get { return ((string[])internalGetGenitiveMonthNames(true).Clone()); }
  2014.            
  2015.             set {
  2016.                 VerifyWritable();
  2017.                 if (value == null) {
  2018.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  2019.                 }
  2020.                 if (value.Length != 13) {
  2021.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 13), "value");
  2022.                 }
  2023.                 CheckNullValue(value, value.Length - 1);
  2024.                 ClearTokenHashTable(true);
  2025.                 this.m_genitiveAbbreviatedMonthNames = value;
  2026.             }
  2027.         }
  2028.        
  2029.         [System.Runtime.InteropServices.ComVisible(false)]
  2030.         public string[] MonthGenitiveNames {
  2031.             get { return ((string[])internalGetGenitiveMonthNames(false).Clone()); }
  2032.            
  2033.             set {
  2034.                 VerifyWritable();
  2035.                 if (value == null) {
  2036.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Array"));
  2037.                 }
  2038.                 if (value.Length != 13) {
  2039.                     throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidArrayLength"), 13), "value");
  2040.                 }
  2041.                 CheckNullValue(value, value.Length - 1);
  2042.                 genitiveMonthNames = value;
  2043.                 ClearTokenHashTable(true);
  2044.             }
  2045.         }
  2046.        
  2047.        
  2048.         //
  2049.         // Get suitable CompareInfo from current DTFI object.
  2050.         //
  2051.        
  2052.         internal CompareInfo CompareInfo {
  2053.             get {
  2054.                 if (m_compareInfo == null) {
  2055.                     // We use the regular GetCompareInfo here to make sure the created CompareInfo object is stored in the
  2056.                     // CompareInfo cache. otherwise we would just create CompareInfo using m_cultureTableRecord.
  2057.                     if (CultureTableRecord.IsCustomCultureId(CultureId))
  2058.                         m_compareInfo = CompareInfo.GetCompareInfo((int)m_cultureTableRecord.ICOMPAREINFO);
  2059.                     else
  2060.                         m_compareInfo = CompareInfo.GetCompareInfo(CultureId);
  2061.                 }
  2062.                
  2063.                 return m_compareInfo;
  2064.             }
  2065.         }
  2066.        
  2067.        
  2068.         private void VerifyWritable()
  2069.         {
  2070.             if (m_isReadOnly) {
  2071.                 throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ReadOnly"));
  2072.             }
  2073.         }
  2074.        
  2075.         //private const DateTimeStyles InvalidDateTimeStyles = unchecked((DateTimeStyles)0xFFFFFF00);
  2076.         private const DateTimeStyles InvalidDateTimeStyles = ~(DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite | DateTimeStyles.AllowInnerWhite | DateTimeStyles.NoCurrentDateDefault | DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal | DateTimeStyles.RoundtripKind);
  2077.        
  2078.         static internal void ValidateStyles(DateTimeStyles style, string parameterName)
  2079.         {
  2080.             if ((style & InvalidDateTimeStyles) != 0) {
  2081.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidDateTimeStyles"), parameterName);
  2082.             }
  2083.             if (((style & (DateTimeStyles.AssumeLocal)) != 0) && ((style & (DateTimeStyles.AssumeUniversal)) != 0)) {
  2084.                 throw new ArgumentException(Environment.GetResourceString("Argument_ConflictingDateTimeStyles"), parameterName);
  2085.             }
  2086.             if (((style & DateTimeStyles.RoundtripKind) != 0) && ((style & (DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal)) != 0)) {
  2087.                 throw new ArgumentException(Environment.GetResourceString("Argument_ConflictingDateTimeRoundtripStyles"), parameterName);
  2088.             }
  2089.         }
  2090.        
  2091.         //
  2092.         // Actions: Return the internal flag used in formatting and parsing.
  2093.         // The flag can be used to indicate things like if genitive forms is used in this DTFi, or if leap year gets different month names.
  2094.         //
  2095.         internal DateTimeFormatFlags FormatFlags {
  2096.             get {
  2097.                 if (formatFlags == DateTimeFormatFlags.NotInitialized) {
  2098.                     if (m_scanDateWords || m_cultureTableRecord.IsSynthetic) {
  2099.                         formatFlags = DateTimeFormatFlags.None;
  2100.                         formatFlags |= (DateTimeFormatFlags)DateTimeFormatInfoScanner.GetFormatFlagGenitiveMonth(MonthNames, internalGetGenitiveMonthNames(false), AbbreviatedMonthNames, internalGetGenitiveMonthNames(true));
  2101.                         formatFlags |= (DateTimeFormatFlags)DateTimeFormatInfoScanner.GetFormatFlagUseSpaceInMonthNames(MonthNames, internalGetGenitiveMonthNames(false), AbbreviatedMonthNames, internalGetGenitiveMonthNames(true));
  2102.                         formatFlags |= (DateTimeFormatFlags)DateTimeFormatInfoScanner.GetFormatFlagUseSpaceInDayNames(DayNames, AbbreviatedDayNames);
  2103.                         formatFlags |= (DateTimeFormatFlags)DateTimeFormatInfoScanner.GetFormatFlagUseHebrewCalendar((int)Calendar.ID);
  2104.                     }
  2105.                     else {
  2106.                         // No customized format, we can use the pre-calculated formatflags.
  2107.                         if (m_isDefaultCalendar) {
  2108.                             formatFlags = this.m_cultureTableRecord.IFORMATFLAGS;
  2109.                         }
  2110.                         else {
  2111.                             BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.FormatFlags] Expected Calendar.ID > 0");
  2112.                             formatFlags = (DateTimeFormatFlags)CalendarTable.Default.IFORMATFLAGS(Calendar.ID);
  2113.                         }
  2114.                     }
  2115.                 }
  2116.                 return (formatFlags);
  2117.             }
  2118.         }
  2119.        
  2120.         internal bool HasForceTwoDigitYears {
  2121.             get {
  2122.                 switch (calendar.ID) {
  2123.                     case (Calendar.CAL_JAPAN):
  2124.                     case (Calendar.CAL_TAIWAN):
  2125.                         // Add a special case for Japanese and Taiwan.
  2126.                         // If is y/yy, do not get (year % 100). "y" will print
  2127.                         // year without leading zero. "yy" will print year with two-digit in leading zero.
  2128.                         // If pattern is yyy/yyyy/..., print year value with two-digit in leading zero.
  2129.                         // So year 5 is "05", and year 125 is "125".
  2130.                         // The reason for not doing (year % 100) is for Taiwan calendar.
  2131.                         // If year 125, then output 125 and not 25.
  2132.                         // Note: OS uses "yyyy" for Taiwan calendar by default.
  2133.                         return true;
  2134.                 }
  2135.                 return false;
  2136.             }
  2137.         }
  2138.        
  2139.         // Returns whether the YearMonthAdjustment function has any fix-up work to do for this culture/calendar.
  2140.         internal bool HasYearMonthAdjustment {
  2141.             get { return ((FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0); }
  2142.         }
  2143.        
  2144.         // This is a callback that the parser can make back into the DTFI to let it fiddle with special
  2145.         // cases associated with that culture or calendar. Currently this only has special cases for
  2146.         // the Hebrew calendar, but this could be extended to other cultures.
  2147.         //
  2148.         // The return value is whether the year and month are actually valid for this calendar.
  2149.         internal bool YearMonthAdjustment(ref int year, ref int month, bool parsedMonthName)
  2150.         {
  2151.             if ((FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0) {
  2152.                
  2153.                 // Special rules to fix up the Hebrew year/month
  2154.                
  2155.                 // When formatting, we only format up to the hundred digit of the Hebrew year, although Hebrew year is now over 5000.
  2156.                 // E.g. if the year is 5763, we only format as 763.
  2157.                 if (year < 1000) {
  2158.                     year += 5000;
  2159.                 }
  2160.                
  2161.                 // Because we need to calculate leap year, we should fall out now for an invalid year.
  2162.                 if (year < Calendar.GetYear(Calendar.MinSupportedDateTime) || year > Calendar.GetYear(Calendar.MaxSupportedDateTime)) {
  2163.                     return false;
  2164.                 }
  2165.                
  2166.                 // To handle leap months, the set of month names in the symbol table does not always correspond to the numbers.
  2167.                 // For non-leap years, month 7 (Adar Bet) is not present, so we need to make using this month invalid and
  2168.                 // shuffle the other months down.
  2169.                 if (parsedMonthName) {
  2170.                     if (!Calendar.IsLeapYear(year)) {
  2171.                         if (month >= 8) {
  2172.                             month--;
  2173.                         }
  2174.                         else if (month == 7) {
  2175.                             return false;
  2176.                         }
  2177.                     }
  2178.                 }
  2179.             }
  2180.             return true;
  2181.         }
  2182.        
  2183.         //
  2184.         // DateTimeFormatInfo tokenizer. This is used by DateTime.Parse() to break input string into tokens.
  2185.         //
  2186.         [NonSerialized()]
  2187.         TokenHashValue[] m_dtfiTokenHash;
  2188.         // The flag to indicate if we need to re-generate date words & formatflags.
  2189.         [NonSerialized()]
  2190.         bool m_scanDateWords = false;
  2191.        
  2192.        
  2193.         private const int TOKEN_HASH_SIZE = 199;
  2194.         private const int SECOND_PRIME = 197;
  2195.         private const string alternativeDateSeparator = "-";
  2196.         private const string invariantDateSeparator = "/";
  2197.         private const string invariantTimeSeparator = ":";
  2198.        
  2199.         //
  2200.         // Year/Month/Day suffixes
  2201.         //
  2202.         internal const string CJKYearSuff = "年";
  2203.         internal const string CJKMonthSuff = "月";
  2204.         internal const string CJKDaySuff = "日";
  2205.        
  2206.         internal const string KoreanYearSuff = "년";
  2207.         internal const string KoreanMonthSuff = "월";
  2208.         internal const string KoreanDaySuff = "일";
  2209.        
  2210.         internal const string KoreanHourSuff = "시";
  2211.         internal const string KoreanMinuteSuff = "분";
  2212.         internal const string KoreanSecondSuff = "초";
  2213.        
  2214.         internal const string CJKHourSuff = "時";
  2215.         internal const string ChineseHourSuff = "时";
  2216.        
  2217.         internal const string CJKMinuteSuff = "分";
  2218.         internal const string CJKSecondSuff = "秒";
  2219.        
  2220.         internal const string LocalTimeMark = "T";
  2221.        
  2222.         internal const string KoreanLangName = "ko";
  2223.         internal const string JapaneseLangName = "ja";
  2224.         internal const string EnglishLangName = "en";
  2225.        
  2226.         private static DateTimeFormatInfo m_jajpDTFI = null;
  2227.         private static DateTimeFormatInfo m_zhtwDTFI = null;
  2228.        
  2229.         //
  2230.         // Create a Japanese DTFI which uses JapaneseCalendar. This is used to parse
  2231.         // date string with Japanese era name correctly even when the supplied DTFI
  2232.         // does not use Japanese calendar.
  2233.         // The created instance is stored in global m_jajpDTFI.
  2234.         //
  2235.         static internal DateTimeFormatInfo GetJapaneseCalendarDTFI()
  2236.         {
  2237.             DateTimeFormatInfo temp = m_jajpDTFI;
  2238.             if (temp == null) {
  2239.                 temp = new CultureInfo("ja-JP", false).DateTimeFormat;
  2240.                 temp.Calendar = JapaneseCalendar.GetDefaultInstance();
  2241.                 m_jajpDTFI = temp;
  2242.             }
  2243.             return (temp);
  2244.         }
  2245.        
  2246.        
  2247.         //
  2248.         // Create a Taiwan DTFI which uses TaiwanCalendar. This is used to parse
  2249.         // date string with era name correctly even when the supplied DTFI
  2250.         // does not use Taiwan calendar.
  2251.         // The created instance is stored in global m_zhtwDTFI.
  2252.         //
  2253.         static internal DateTimeFormatInfo GetTaiwanCalendarDTFI()
  2254.         {
  2255.             DateTimeFormatInfo temp = m_zhtwDTFI;
  2256.             if (temp == null) {
  2257.                 temp = new CultureInfo("zh-TW", false).DateTimeFormat;
  2258.                 temp.Calendar = TaiwanCalendar.GetDefaultInstance();
  2259.                 m_zhtwDTFI = temp;
  2260.             }
  2261.             return (temp);
  2262.         }
  2263.        
  2264.        
  2265.         // DTFI properties should call this when the setter are called.
  2266.         private void ClearTokenHashTable(bool scanDateWords)
  2267.         {
  2268.             m_dtfiTokenHash = null;
  2269.             m_dateWords = null;
  2270.             // The properties in this class have been changed, and we need to re-generate
  2271.             // date words & format flags, instead of using the table values.
  2272.             m_scanDateWords = scanDateWords;
  2273.             formatFlags = DateTimeFormatFlags.NotInitialized;
  2274.         }
  2275.        
  2276.         internal TokenHashValue[] CreateTokenHashTable()
  2277.         {
  2278.             TokenHashValue[] temp = m_dtfiTokenHash;
  2279.             if (temp == null) {
  2280.                 temp = new TokenHashValue[TOKEN_HASH_SIZE];
  2281.                
  2282.                 InsertHash(temp, ",", TokenType.IgnorableSymbol, 0);
  2283.                 InsertHash(temp, ".", TokenType.IgnorableSymbol, 0);
  2284.                
  2285.                 InsertHash(temp, this.TimeSeparator, TokenType.SEP_Time, 0);
  2286.                 InsertHash(temp, this.AMDesignator, TokenType.SEP_Am | TokenType.Am, 0);
  2287.                 InsertHash(temp, this.PMDesignator, TokenType.SEP_Pm | TokenType.Pm, 1);
  2288.                
  2289.                 if (CultureName.Equals("sq-AL")) {
  2290.                     // Algerian allows time formats like "12:00.PD"
  2291.                     InsertHash(temp, "." + this.AMDesignator, TokenType.SEP_Am | TokenType.Am, 0);
  2292.                     InsertHash(temp, "." + this.PMDesignator, TokenType.SEP_Pm | TokenType.Pm, 1);
  2293.                 }
  2294.                
  2295.                 // CJK suffix
  2296.                 InsertHash(temp, CJKYearSuff, TokenType.SEP_YearSuff, 0);
  2297.                 InsertHash(temp, KoreanYearSuff, TokenType.SEP_YearSuff, 0);
  2298.                 InsertHash(temp, CJKMonthSuff, TokenType.SEP_MonthSuff, 0);
  2299.                 InsertHash(temp, KoreanMonthSuff, TokenType.SEP_MonthSuff, 0);
  2300.                 InsertHash(temp, CJKDaySuff, TokenType.SEP_DaySuff, 0);
  2301.                 InsertHash(temp, KoreanDaySuff, TokenType.SEP_DaySuff, 0);
  2302.                
  2303.                 InsertHash(temp, CJKHourSuff, TokenType.SEP_HourSuff, 0);
  2304.                 InsertHash(temp, ChineseHourSuff, TokenType.SEP_HourSuff, 0);
  2305.                 InsertHash(temp, CJKMinuteSuff, TokenType.SEP_MinuteSuff, 0);
  2306.                 InsertHash(temp, CJKSecondSuff, TokenType.SEP_SecondSuff, 0);
  2307.                
  2308.                 if (LanguageName.Equals(KoreanLangName)) {
  2309.                     // Korean suffix
  2310.                     InsertHash(temp, KoreanHourSuff, TokenType.SEP_HourSuff, 0);
  2311.                     InsertHash(temp, KoreanMinuteSuff, TokenType.SEP_MinuteSuff, 0);
  2312.                     InsertHash(temp, KoreanSecondSuff, TokenType.SEP_SecondSuff, 0);
  2313.                 }
  2314.                
  2315.                 string[] dateWords = null;
  2316.                 DateTimeFormatInfoScanner scanner = null;
  2317.                
  2318.                 // Get the all of the long date pattern. The getter will check if the default LongDatePattern
  2319.                 // is in the standard list or not. If not, m_scanDateWords will be true, and we will
  2320.                 // need to scan the date words.
  2321.                 // Note that dateWords is used as a temp buffer here. It will be reset as the real date words later.
  2322.                 if (!m_scanDateWords) {
  2323.                     dateWords = ClonedAllLongDatePatterns;
  2324.                 }
  2325.                 if (m_scanDateWords || m_cultureTableRecord.IsSynthetic) {
  2326.                     scanner = new DateTimeFormatInfoScanner();
  2327.                     // Enumarate all LongDatePatterns, and get the DateWords and scan for month postfix.
  2328.                     m_dateWords = dateWords = scanner.GetDateWordsOfDTFI(this);
  2329.                     // Ensure the formatflags is initialized.
  2330.                     DateTimeFormatFlags flag = FormatFlags;
  2331.                     m_scanDateWords = false;
  2332.                 }
  2333.                 else {
  2334.                     // Use the table value.
  2335.                     dateWords = this.DateWords;
  2336.                     ;
  2337.                 }
  2338.                
  2339.                 // For some cultures, the date separator works more like a comma, being allowed before or after any date part.
  2340.                 // In this cultures, we do not use normal date separator since we disallow date separator after a date terminal state.
  2341.                 // This is determinted in DateTimeFormatInfoScanner. Use this flag to determine if we should treat date separator as ignorable symbol.
  2342.                 bool useDateSepAsIgnorableSymbol = false;
  2343.                
  2344.                 string monthPostfix = null;
  2345.                 if (dateWords != null) {
  2346.                     // There are DateWords. It could be a real date word (such as "de"), or a monthPostfix.
  2347.                     // The monthPostfix starts with '\xfffe' (MonthPostfixChar), followed by the real monthPostfix.
  2348.                     for (int i = 0; i < dateWords.Length; i++) {
  2349.                         switch (dateWords[i][0]) {
  2350.                             case DateTimeFormatInfoScanner.MonthPostfixChar:
  2351.                                 // This is a month postfix
  2352.                                 // Get the real month postfix.
  2353.                                 monthPostfix = dateWords[i].Substring(1);
  2354.                                 // Add the month name + postfix into the token.
  2355.                                 AddMonthNames(temp, monthPostfix);
  2356.                                 break;
  2357.                             case DateTimeFormatInfoScanner.IgnorableSymbolChar:
  2358.                                 string symbol = dateWords[i].Substring(1);
  2359.                                 InsertHash(temp, symbol, TokenType.IgnorableSymbol, 0);
  2360.                                 if (this.DateSeparator.Trim(null).Equals(symbol)) {
  2361.                                     // The date separator is the same as the ingorable symbol.
  2362.                                     useDateSepAsIgnorableSymbol = true;
  2363.                                 }
  2364.                                 break;
  2365.                             default:
  2366.                                 InsertHash(temp, dateWords[i], TokenType.DateWordToken, 0);
  2367.                                 if (CultureName.Equals("eu-ES")) {
  2368.                                     // Basque has date words with leading dots
  2369.                                     InsertHash(temp, "." + dateWords[i], TokenType.DateWordToken, 0);
  2370.                                 }
  2371.                                 break;
  2372.                         }
  2373.                     }
  2374.                 }
  2375.                
  2376.                 if (!useDateSepAsIgnorableSymbol) {
  2377.                     // Use the normal date separator.
  2378.                     InsertHash(temp, this.DateSeparator, TokenType.SEP_Date, 0);
  2379.                 }
  2380.                 // Add the regular month names.
  2381.                 AddMonthNames(temp, null);
  2382.                
  2383.                 // Add the abbreviated month names.
  2384.                 for (int i = 1; i <= 13; i++) {
  2385.                     InsertHash(temp, GetAbbreviatedMonthName(i), TokenType.MonthToken, i);
  2386.                 }
  2387.                
  2388.                
  2389.                 if (CultureName.Equals("gl-ES")) {
  2390.                     //
  2391.                     // Special case for gl-ES. It has a potential incorrect format in year/month: MMMM'de 'yyyy.
  2392.                     // It probably has to be MMMM' de 'yyyy.
  2393.                     //
  2394.                    
  2395.                     // We keep this so that we can still parse dates formatted in the older version.
  2396.                     for (int i = 1; i <= 13; i++) {
  2397.                         string str;
  2398.                         //str = internalGetMonthName(i, MonthNameStyles.Regular, false);
  2399.                         // We have to call public methods here to work with inherited DTFI.
  2400.                         // Insert the month name first, so that they are at the front of abbrevaited
  2401.                         // month names.
  2402.                         str = GetMonthName(i);
  2403.                         if (str.Length > 0) {
  2404.                             // Insert the month name with the postfix first, so it can be matched first.
  2405.                             InsertHash(temp, str + "de", TokenType.MonthToken, i);
  2406.                         }
  2407.                     }
  2408.                 }
  2409.                
  2410.                 if ((FormatFlags & DateTimeFormatFlags.UseGenitiveMonth) != 0) {
  2411.                     for (int i = 1; i <= 13; i++) {
  2412.                         string str;
  2413.                         str = internalGetMonthName(i, MonthNameStyles.Genitive, false);
  2414.                         InsertHash(temp, str, TokenType.MonthToken, i);
  2415.                     }
  2416.                 }
  2417.                
  2418.                 if ((FormatFlags & DateTimeFormatFlags.UseLeapYearMonth) != 0) {
  2419.                     for (int i = 1; i <= 13; i++) {
  2420.                         string str;
  2421.                         str = internalGetMonthName(i, MonthNameStyles.LeapYear, false);
  2422.                         InsertHash(temp, str, TokenType.MonthToken, i);
  2423.                     }
  2424.                 }
  2425.                
  2426.                 for (int i = 0; i < 7; i++) {
  2427.                     //String str = GetDayOfWeekNames()[i];
  2428.                     // We have to call public methods here to work with inherited DTFI.
  2429.                     string str = GetDayName((DayOfWeek)i);
  2430.                     InsertHash(temp, str, TokenType.DayOfWeekToken, i);
  2431.                    
  2432.                     str = GetAbbreviatedDayName((DayOfWeek)i);
  2433.                     InsertHash(temp, str, TokenType.DayOfWeekToken, i);
  2434.                    
  2435.                 }
  2436.                
  2437.                 int[] eras = calendar.Eras;
  2438.                 for (int i = 1; i <= eras.Length; i++) {
  2439.                     InsertHash(temp, GetEraName(i), TokenType.EraToken, i);
  2440.                     InsertHash(temp, GetAbbreviatedEraName(i), TokenType.EraToken, i);
  2441.                 }
  2442.                
  2443.                 if (LanguageName.Equals(JapaneseLangName)) {
  2444.                     // Japanese allows day of week forms like: "(Tue)"
  2445.                     for (int i = 0; i < 7; i++) {
  2446.                         string specialDayOfWeek = "(" + GetAbbreviatedDayName((DayOfWeek)i) + ")";
  2447.                         InsertHash(temp, specialDayOfWeek, TokenType.DayOfWeekToken, i);
  2448.                     }
  2449.                     if (this.Calendar.GetType() != typeof(JapaneseCalendar)) {
  2450.                         // Special case for Japanese. If this is a Japanese DTFI, and the calendar is not Japanese calendar,
  2451.                         // we will check Japanese Era name as well when the calendar is Gregorian.
  2452.                         DateTimeFormatInfo jaDtfi = GetJapaneseCalendarDTFI();
  2453.                         for (int i = 1; i <= jaDtfi.Calendar.Eras.Length; i++) {
  2454.                             InsertHash(temp, jaDtfi.GetEraName(i), TokenType.JapaneseEraToken, i);
  2455.                             InsertHash(temp, jaDtfi.GetAbbreviatedEraName(i), TokenType.JapaneseEraToken, i);
  2456.                             // m_abbrevEnglishEraNames[0] contains the name for era 1, so the token value is i+1.
  2457.                             InsertHash(temp, jaDtfi.AbbreviatedEnglishEraNames[i - 1], TokenType.JapaneseEraToken, i);
  2458.                         }
  2459.                     }
  2460.                 }
  2461.                 else if (CultureName.Equals("zh-TW")) {
  2462.                     DateTimeFormatInfo twDtfi = GetTaiwanCalendarDTFI();
  2463.                     for (int i = 1; i <= twDtfi.Calendar.Eras.Length; i++) {
  2464.                         if (twDtfi.GetEraName(i).Length > 0) {
  2465.                             InsertHash(temp, twDtfi.GetEraName(i), TokenType.TEraToken, i);
  2466.                         }
  2467.                     }
  2468.                 }
  2469.                
  2470.                 InsertHash(temp, InvariantInfo.AMDesignator, TokenType.SEP_Am | TokenType.Am, 0);
  2471.                 InsertHash(temp, InvariantInfo.PMDesignator, TokenType.SEP_Pm | TokenType.Pm, 1);
  2472.                
  2473.                 // Add invariant month names and day names.
  2474.                 for (int i = 1; i <= 12; i++) {
  2475.                     string str;
  2476.                     // We have to call public methods here to work with inherited DTFI.
  2477.                     // Insert the month name first, so that they are at the front of abbrevaited
  2478.                     // month names.
  2479.                     str = InvariantInfo.GetMonthName(i);
  2480.                     InsertHash(temp, str, TokenType.MonthToken, i);
  2481.                     str = InvariantInfo.GetAbbreviatedMonthName(i);
  2482.                     InsertHash(temp, str, TokenType.MonthToken, i);
  2483.                 }
  2484.                
  2485.                 for (int i = 0; i < 7; i++) {
  2486.                     // We have to call public methods here to work with inherited DTFI.
  2487.                     string str = InvariantInfo.GetDayName((DayOfWeek)i);
  2488.                     InsertHash(temp, str, TokenType.DayOfWeekToken, i);
  2489.                    
  2490.                     str = InvariantInfo.GetAbbreviatedDayName((DayOfWeek)i);
  2491.                     InsertHash(temp, str, TokenType.DayOfWeekToken, i);
  2492.                    
  2493.                 }
  2494.                
  2495.                 for (int i = 0; i < AbbreviatedEnglishEraNames.Length; i++) {
  2496.                     // m_abbrevEnglishEraNames[0] contains the name for era 1, so the token value is i+1.
  2497.                     InsertHash(temp, AbbreviatedEnglishEraNames[i], TokenType.EraToken, i + 1);
  2498.                 }
  2499.                
  2500.                 InsertHash(temp, LocalTimeMark, TokenType.SEP_LocalTimeMark, 0);
  2501.                 InsertHash(temp, DateTimeParse.GMTName, TokenType.TimeZoneToken, 0);
  2502.                 InsertHash(temp, DateTimeParse.ZuluName, TokenType.TimeZoneToken, 0);
  2503.                
  2504.                 InsertHash(temp, invariantDateSeparator, TokenType.SEP_Date, 0);
  2505.                 InsertHash(temp, invariantTimeSeparator, TokenType.SEP_Time, 0);
  2506.                
  2507.                 if (CultureName.Equals("ky-KG")) {
  2508.                     // For some cultures, the date separator works more like a comma, being allowed before or after any date part
  2509.                     InsertHash(temp, alternativeDateSeparator, TokenType.IgnorableSymbol, 0);
  2510.                 }
  2511.                 else {
  2512.                     InsertHash(temp, alternativeDateSeparator, TokenType.SEP_Date, 0);
  2513.                 }
  2514.                
  2515.                 m_dtfiTokenHash = temp;
  2516.             }
  2517.             return (temp);
  2518.         }
  2519.        
  2520.         private void AddMonthNames(TokenHashValue[] temp, string monthPostfix)
  2521.         {
  2522.             for (int i = 1; i <= 13; i++) {
  2523.                 string str;
  2524.                 //str = internalGetMonthName(i, MonthNameStyles.Regular, false);
  2525.                 // We have to call public methods here to work with inherited DTFI.
  2526.                 // Insert the month name first, so that they are at the front of abbrevaited
  2527.                 // month names.
  2528.                 str = GetMonthName(i);
  2529.                 if (str.Length > 0) {
  2530.                     if (monthPostfix != null) {
  2531.                         // Insert the month name with the postfix first, so it can be matched first.
  2532.                         InsertHash(temp, str + monthPostfix, TokenType.MonthToken, i);
  2533.                     }
  2534.                     else {
  2535.                         InsertHash(temp, str, TokenType.MonthToken, i);
  2536.                     }
  2537.                 }
  2538.                 str = GetAbbreviatedMonthName(i);
  2539.                 InsertHash(temp, str, TokenType.MonthToken, i);
  2540.             }
  2541.            
  2542.         }
  2543.        
  2544.         ////////////////////////////////////////////////////////////////////////
  2545.         //
  2546.         // Actions:
  2547.         // Try to parse the current word to see if it is a Hebrew number.
  2548.         // Tokens will be updated accordingly.
  2549.         // This is called by the Lexer of DateTime.Parse().
  2550.         //
  2551.         // Unlike most of the functions in this class, the return value indicates
  2552.         // whether or not it started to parse. The badFormat parameter indicates
  2553.         // if parsing began, but the format was bad.
  2554.         //
  2555.         ////////////////////////////////////////////////////////////////////////
  2556.        
  2557.         private static bool TryParseHebrewNumber(ref __DTString str, out bool badFormat, out int number)
  2558.         {
  2559.            
  2560.             number = -1;
  2561.             badFormat = false;
  2562.            
  2563.             int i = str.Index;
  2564.             if (!HebrewNumber.IsDigit(str.Value[i])) {
  2565.                 // If the current character is not a Hebrew digit, just return false.
  2566.                 // There is no chance that we can parse a valid Hebrew number from here.
  2567.                 return (false);
  2568.             }
  2569.             // The current character is a Hebrew digit. Try to parse this word as a Hebrew number.
  2570.             HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);
  2571.             HebrewNumberParsingState state;
  2572.            
  2573.             do {
  2574.                 state = HebrewNumber.ParseByChar(str.Value[i++], ref context);
  2575.                 switch (state) {
  2576.                     case HebrewNumberParsingState.InvalidHebrewNumber:
  2577.                     case HebrewNumberParsingState.NotHebrewDigit:
  2578.                         // Not a valid Hebrew number.
  2579.                         // The current character is not a Hebrew digit character.
  2580.                         // Break out so that we don't continue to try parse this as a Hebrew number.
  2581.                         return (false);
  2582.                 }
  2583.             }
  2584.             while (i < str.Value.Length && (state != HebrewNumberParsingState.FoundEndOfHebrewNumber));
  2585.            
  2586.             // When we are here, we are either at the end of the string, or we find a valid Hebrew number.
  2587.             BCLDebug.Assert(state == HebrewNumberParsingState.ContinueParsing || state == HebrewNumberParsingState.FoundEndOfHebrewNumber, "Invalid returned state from HebrewNumber.ParseByChar()");
  2588.            
  2589.             if (state != HebrewNumberParsingState.FoundEndOfHebrewNumber) {
  2590.                 // We reach end of the string but we can't find a terminal state in parsing Hebrew number.
  2591.                 return (false);
  2592.             }
  2593.            
  2594.             // We have found a valid Hebrew number. Update the index.
  2595.             str.Advance(i - str.Index);
  2596.            
  2597.             // Get the final Hebrew number value from the HebrewNumberParsingContext.
  2598.             number = context.result;
  2599.            
  2600.             return (true);
  2601.         }
  2602.        
  2603.         private static bool IsHebrewChar(char ch)
  2604.         {
  2605.             return (ch >= '֐' && ch <= '׿');
  2606.         }
  2607.        
  2608.         internal bool Tokenize(TokenType TokenMask, out TokenType tokenType, out int tokenValue, ref __DTString str)
  2609.         {
  2610.             tokenType = TokenType.UnknownToken;
  2611.             tokenValue = 0;
  2612.            
  2613.             TokenHashValue value;
  2614.             BCLDebug.Assert(str.Index < str.Value.Length, "DateTimeFormatInfo.Tokenize(): start < value.Length");
  2615.            
  2616.             char ch = str.m_current;
  2617.             bool isLetter = Char.IsLetter(ch);
  2618.             if (isLetter) {
  2619.                 ch = Char.ToLower(ch, CultureInfo.CurrentCulture);
  2620.                 if (IsHebrewChar(ch) && TokenMask == TokenType.RegularTokenMask) {
  2621.                     bool badFormat;
  2622.                     if (TryParseHebrewNumber(ref str, out badFormat, out tokenValue)) {
  2623.                         if (badFormat) {
  2624.                             tokenType = TokenType.UnknownToken;
  2625.                             return (false);
  2626.                         }
  2627.                         // This is a Hebrew number.
  2628.                         // Do nothing here. TryParseHebrewNumber() will update token accordingly.
  2629.                         tokenType = TokenType.HebrewNumber;
  2630.                         return (true);
  2631.                     }
  2632.                 }
  2633.             }
  2634.            
  2635.            
  2636.             int hashcode = ch % TOKEN_HASH_SIZE;
  2637.             int hashProbe = 1 + ch % SECOND_PRIME;
  2638.             int remaining = str.len - str.Index;
  2639.             int i = 0;
  2640.            
  2641.             TokenHashValue[] hashTable = m_dtfiTokenHash;
  2642.             if (hashTable == null) {
  2643.                 hashTable = CreateTokenHashTable();
  2644.             }
  2645.             do {
  2646.                 value = hashTable[hashcode];
  2647.                 if (value == null) {
  2648.                     // Not found.
  2649.                     break;
  2650.                 }
  2651.                 // Check this value has the right category (regular token or separator token) that we are looking for.
  2652.                 if (((int)value.tokenType & (int)TokenMask) > 0 && value.tokenString.Length <= remaining) {
  2653.                     if (String.Compare(str.Value, str.Index, value.tokenString, 0, value.tokenString.Length, true, CultureInfo.CurrentCulture) == 0) {
  2654.                         if (isLetter) {
  2655.                             // If this token starts with a letter, make sure that we won't allow partial match. So you can't tokenize "MarchWed" separately.
  2656.                             int nextCharIndex;
  2657.                             if ((nextCharIndex = str.Index + value.tokenString.Length) < str.len) {
  2658.                                 // Check word boundary. The next character should NOT be a letter.
  2659.                                 char nextCh = str.Value[nextCharIndex];
  2660.                                 if (Char.IsLetter(nextCh)) {
  2661.                                     return (false);
  2662.                                 }
  2663.                             }
  2664.                         }
  2665.                         tokenType = value.tokenType & TokenMask;
  2666.                         tokenValue = value.tokenValue;
  2667.                         str.Advance(value.tokenString.Length);
  2668.                         return (true);
  2669.                     }
  2670.                     else if (value.tokenType == TokenType.MonthToken && HasSpacesInMonthNames) {
  2671.                         // For month token, we will match the month names which have spaces.
  2672.                         int matchStrLen = 0;
  2673.                         if (str.MatchSpecifiedWords(value.tokenString, true, ref matchStrLen)) {
  2674.                             tokenType = value.tokenType & TokenMask;
  2675.                             tokenValue = value.tokenValue;
  2676.                             str.Advance(matchStrLen);
  2677.                             return (true);
  2678.                         }
  2679.                     }
  2680.                     else if (value.tokenType == TokenType.DayOfWeekToken && HasSpacesInDayNames) {
  2681.                         // For month token, we will match the month names which have spaces.
  2682.                         int matchStrLen = 0;
  2683.                         if (str.MatchSpecifiedWords(value.tokenString, true, ref matchStrLen)) {
  2684.                             tokenType = value.tokenType & TokenMask;
  2685.                             tokenValue = value.tokenValue;
  2686.                             str.Advance(matchStrLen);
  2687.                             return (true);
  2688.                         }
  2689.                     }
  2690.                 }
  2691.                 i++;
  2692.                 hashcode += hashProbe;
  2693.                 if (hashcode >= TOKEN_HASH_SIZE)
  2694.                     hashcode -= TOKEN_HASH_SIZE;
  2695.             }
  2696.             while (i < TOKEN_HASH_SIZE);
  2697.            
  2698.             return (false);
  2699.         }
  2700.        
  2701.         void InsertAtCurrentHashNode(TokenHashValue[] hashTable, string str, char ch, TokenType tokenType, int tokenValue, int pos, int hashcode, int hashProbe)
  2702.         {
  2703.             // Remember the current slot.
  2704.             TokenHashValue previousNode = hashTable[hashcode];
  2705.            
  2706.             //// Console.WriteLine(" Insert Key: {0} in {1}", str, slotToInsert);
  2707.             // Insert the new node into the current slot.
  2708.             hashTable[hashcode] = new TokenHashValue(str, tokenType, tokenValue);
  2709.             ;
  2710.            
  2711.             while (++pos < TOKEN_HASH_SIZE) {
  2712.                 hashcode += hashProbe;
  2713.                 if (hashcode >= TOKEN_HASH_SIZE)
  2714.                     hashcode -= TOKEN_HASH_SIZE;
  2715.                 // Remember this slot
  2716.                 TokenHashValue temp = hashTable[hashcode];
  2717.                
  2718.                 if (temp != null && Char.ToLower(temp.tokenString[0], CultureInfo.CurrentCulture) != ch) {
  2719.                     continue;
  2720.                 }
  2721.                 // Put the previous slot into this slot.
  2722.                 hashTable[hashcode] = previousNode;
  2723.                 //// Console.WriteLine(" Move {0} to slot {1}", previousNode.tokenString, hashcode);
  2724.                 if (temp == null) {
  2725.                     // Done
  2726.                     return;
  2727.                 }
  2728.                 previousNode = temp;
  2729.             }
  2730.             ;
  2731.             BCLDebug.Assert(true, "The hashtable is full. This should not happen.");
  2732.         }
  2733.        
  2734.         void InsertHash(TokenHashValue[] hashTable, string str, TokenType tokenType, int tokenValue)
  2735.         {
  2736.             // The month of the 13th month is allowed to be null, so make sure that we ignore null value here.
  2737.             if (str == null || str.Length == 0) {
  2738.                 return;
  2739.             }
  2740.             TokenHashValue value;
  2741.             int i = 0;
  2742.             // If there is whitespace characters in the beginning and end of the string, trim them since whitespaces are skipped by
  2743.             // DateTime.Parse().
  2744.             if (Char.IsWhiteSpace(str[0]) || Char.IsWhiteSpace(str[str.Length - 1])) {
  2745.                 str = str.Trim(null);
  2746.                 // Trim white space characters.
  2747.             }
  2748.             char ch = Char.ToLower(str[0], CultureInfo.CurrentCulture);
  2749.             int hashcode = ch % TOKEN_HASH_SIZE;
  2750.             int hashProbe = 1 + ch % SECOND_PRIME;
  2751.             do {
  2752.                 value = hashTable[hashcode];
  2753.                 if (value == null) {
  2754.                     //// Console.WriteLine(" Put Key: {0} in {1}", str, hashcode);
  2755.                     hashTable[hashcode] = new TokenHashValue(str, tokenType, tokenValue);
  2756.                     return;
  2757.                 }
  2758.                 else {
  2759.                     // Collision happens. Find another slot.
  2760.                     if (str.Length >= value.tokenString.Length) {
  2761.                         // If there are two tokens with the same prefix, we have to make sure that the longer token should be at the front of
  2762.                         // the shorter ones.
  2763.                         if (String.Compare(str, 0, value.tokenString, 0, value.tokenString.Length, true, CultureInfo.CurrentCulture) == 0) {
  2764.                             if (str.Length > value.tokenString.Length) {
  2765.                                 // The str to be inserted has the same prefix as the current token, and str is longer.
  2766.                                 // Insert str into this node, and shift every node behind it.
  2767.                                 InsertAtCurrentHashNode(hashTable, str, ch, tokenType, tokenValue, i, hashcode, hashProbe);
  2768.                                 return;
  2769.                             }
  2770.                             else {
  2771.                                 // Same token. If they have different types (regular token vs separator token. Add them.
  2772.                                 if (((int)tokenType & 65280) != ((int)value.tokenType & 65280)) {
  2773.                                     value.tokenType |= tokenType;
  2774.                                     if (tokenValue != 0) {
  2775.                                         value.tokenValue = tokenValue;
  2776.                                     }
  2777.                                 }
  2778.                                 // The token to be inserted is already in the table. Skip it.
  2779.                             }
  2780.                         }
  2781.                     }
  2782.                 }
  2783.                 //// Console.WriteLine(" COLLISION. Old Key: {0}, New Key: {1}", hashTable[hashcode].tokenString, str);
  2784.                 i++;
  2785.                 hashcode += hashProbe;
  2786.                 if (hashcode >= TOKEN_HASH_SIZE)
  2787.                     hashcode -= TOKEN_HASH_SIZE;
  2788.             }
  2789.             while (i < TOKEN_HASH_SIZE);
  2790.             BCLDebug.Assert(true, "The hashtable is full. This should not happen.");
  2791.         }
  2792.        
  2793.         static internal string GetCalendarInfo(int culture, int calendar, int calType)
  2794.         {
  2795.             int size = Microsoft.Win32.Win32Native.GetCalendarInfo(culture, calendar, calType, null, 0, IntPtr.Zero);
  2796.             if (size > 0) {
  2797.                 StringBuilder buffer = new StringBuilder(size);
  2798.                 size = Microsoft.Win32.Win32Native.GetCalendarInfo(culture, calendar, calType, buffer, size, IntPtr.Zero);
  2799.                 if (size > 0)
  2800.                     return buffer.ToString(0, size - 1);
  2801.                 // Exclude the null termination.
  2802.             }
  2803.             return null;
  2804.         }
  2805.        
  2806.         // Win32 Constants for calling GetCalendarInfo().
  2807.         internal const int CAL_SCALNAME = 2;
  2808.         // native name of calendar
  2809.     }
  2810.     // class DateTimeFormatInfo
  2811.     internal class TokenHashValue
  2812.     {
  2813.         internal string tokenString;
  2814.         internal TokenType tokenType;
  2815.         internal int tokenValue;
  2816.        
  2817.         internal TokenHashValue(string tokenString, TokenType tokenType, int tokenValue)
  2818.         {
  2819.             this.tokenString = tokenString;
  2820.             this.tokenType = tokenType;
  2821.             this.tokenValue = tokenValue;
  2822.         }
  2823.     }
  2824. }

Developer Fusion