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

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

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. namespace System.Globalization
  16. {
  17.     using System;
  18.     using System.Text;
  19.    
  20.     ////////////////////////////////////////////////////////////////////////////
  21.     //
  22.     // Rules for the Hebrew calendar:
  23.     // - The Hebrew calendar is both a Lunar (months) and Solar (years)
  24.     // calendar, but allows for a week of seven days.
  25.     // - Days begin at sunset.
  26.     // - Leap Years occur in the 3, 6, 8, 11, 14, 17, & 19th years of a
  27.     // 19-year cycle. Year = leap iff ((7y+1) mod 19 < 7).
  28.     // - There are 12 months in a common year and 13 months in a leap year.
  29.     // - In a common year, the 6th month, Adar, has 29 days. In a leap
  30.     // year, the 6th month, Adar I, has 30 days and the leap month,
  31.     // Adar II, has 29 days.
  32.     // - Common years have 353-355 days. Leap years have 383-385 days.
  33.     // - The Hebrew new year (Rosh HaShanah) begins on the 1st of Tishri,
  34.     // the 7th month in the list below.
  35.     // - The new year may not begin on Sunday, Wednesday, or Friday.
  36.     // - If the new year would fall on a Tuesday and the conjunction of
  37.     // the following year were at midday or later, the new year is
  38.     // delayed until Thursday.
  39.     // - If the new year would fall on a Monday after a leap year, the
  40.     // new year is delayed until Tuesday.
  41.     // - The length of the 8th and 9th months vary from year to year,
  42.     // depending on the overall length of the year.
  43.     // - The length of a year is determined by the dates of the new
  44.     // years (Tishri 1) preceding and following the year in question.
  45.     // - The 2th month is long (30 days) if the year has 355 or 385 days.
  46.     // - The 3th month is short (29 days) if the year has 353 or 383 days.
  47.     // - The Hebrew months are:
  48.     // 1. Tishri (30 days)
  49.     // 2. Heshvan (29 or 30 days)
  50.     // 3. Kislev (29 or 30 days)
  51.     // 4. Teveth (29 days)
  52.     // 5. Shevat (30 days)
  53.     // 6. Adar I (30 days)
  54.     // 7. Adar {II} (29 days, this only exists if that year is a leap year)
  55.     // 8. Nisan (30 days)
  56.     // 9. Iyyar (29 days)
  57.     // 10. Sivan (30 days)
  58.     // 11. Tammuz (29 days)
  59.     // 12. Av (30 days)
  60.     // 13. Elul (29 days)
  61.     //
  62.     ////////////////////////////////////////////////////////////////////////////
  63. /*
  64.     **  Calendar support range:
  65.     **      Calendar    Minimum    Maximum
  66.     **      ==========  ==========  ==========
  67.     **      Gregorian  1583/01/01  2239/09/29
  68.     **      Hebrew      5343/04/07  5999/13/29
  69.     */   
  70.    
  71.     // Includes CHebrew implemetation;i.e All the code necessary for converting
  72.     // Gregorian to Hebrew Lunar from 1583 to 2239.
  73.    
  74.    
  75.     [Serializable()]
  76.     [System.Runtime.InteropServices.ComVisible(true)]
  77.     public class HebrewCalendar : Calendar
  78.     {
  79.        
  80.        
  81.         public static readonly int HebrewEra = 1;
  82.        
  83.         internal const int DatePartYear = 0;
  84.         internal const int DatePartDayOfYear = 1;
  85.         internal const int DatePartMonth = 2;
  86.         internal const int DatePartDay = 3;
  87.         internal const int DatePartDayOfWeek = 4;
  88.        
  89.         //
  90.         // Hebrew Translation Table.
  91.         //
  92.         // This table is used to get the following Hebrew calendar information for a
  93.         // given Gregorian year:
  94.         // 1. The day of the Hebrew month corresponding to Gregorian January 1st
  95.         // for a given Gregorian year.
  96.         // 2. The month of the Hebrew month corresponding to Gregorian January 1st
  97.         // for a given Gregorian year.
  98.         // The information is not directly in the table. Instead, the info is decoded
  99.         // by special values (numbers above 29 and below 1).
  100.         // 3. The type of the Hebrew year for a given Gregorian year.
  101.         //
  102.        
  103. /*
  104.             More notes:
  106.             This table includes 2 numbers for each year.
  107.             The offset into the table determines the year. (offset 0 is Gregorian year 1500)
  108.             1st number determines the day of the Hebrew month coresponeds to January 1st.
  109.             2nd number determines the type of the Hebrew year. (the type determines how
  110.             many days are there in the year.)
  112.             normal years : 1 = 353 days  2 = 354 days  3 = 355 days.
  113.             Leap years  : 4 = 383        5  384        6 = 385 days.
  115.             A 99 means the year is not supported for translation.
  116.             for convenience the table was defined for 750 year,
  117.             but only 640 years are supported. (from 1583 to 2239)
  118.             the years before 1582 (starting of Georgian calander)
  119.             and after 2239, are filled with 99.
  121.             Greogrian January 1st falls usually in Tevet (4th month). Tevet has always 29 days.
  122.             That's why, there no nead to specify the lunar month in the table.
  123.             There are exceptions, these are coded by giving numbers above 29 and below 1.
  124.             Actual decoding is takenig place whenever fetching information from the table.
  125.             The function for decoding is in GetLunarMonthDay().
  127.             Example:
  128.                 The data for 2000 - 2005 A.D. is:
  130.                     23,6,6,1,17,2,27,6,7,3,        // 2000 - 2004
  132.                 For year 2000, we know it has a Hebrew year type 6, which means it has 385 days.
  133.                 And 1/1/2000 A.D. is Hebrew year 5760, 23rd day of 4th month.
  134.         */       
  135.        
  136.         //
  137.         // Jewish Era in use today is dated from the supposed year of the
  138.         // Creation with its beginning in 3761 B.C.
  139.         //
  140.        
  141.         // The Hebrew year of Gregorian 1st year AD.
  142.         // 0001/01/01 AD is Hebrew 3760/01/01
  143.         private const int HebrewYearOf1AD = 3760;
  144.        
  145.         // The first Gregorian year in m_HebrewTable.
  146.         private const int FirstGregorianTableYear = 1583;
  147.         // == Hebrew Year 5343
  148.         // The last Gregorian year in m_HebrewTable.
  149.         private const int LastGregorianTableYear = 2239;
  150.         // == Hebrew Year 5999
  151.         private const int TABLESIZE = (LastGregorianTableYear - FirstGregorianTableYear);
  152.        
  153.         private const int m_minHebrewYear = HebrewYearOf1AD + FirstGregorianTableYear;
  154.         // == 5343
  155.         private const int m_maxHebrewYear = HebrewYearOf1AD + LastGregorianTableYear;
  156.         // == 5999
  157.         private static readonly int[] m_HebrewTable = {7, 3, 17, 3, 0, 4, 11, 2, 21, 6,
  158.         1, 3, 13, 2, 25, 4, 5, 3, 16, 2,
  159.         27, 6, 9, 1, 20, 2, 0, 6, 11, 3,
  160.         23, 4, 4, 2, 14, 3, 27, 4, 8, 2,
  161.         18, 3, 28, 6, 11, 1, 22, 5, 2, 3,
  162.         12, 3, 25, 4, 6, 2, 16, 3, 26, 6,
  163.         8, 2, 20, 1, 0, 6, 11, 2, 24, 4,
  164.         4, 3, 15, 2, 25, 6, 8, 1, 19, 2,
  165.         29, 6, 9, 3, 22, 4, 3, 2, 13, 3,
  166.         25, 4, 6, 3, 17, 2, 27, 6, 7, 3,
  167.         19, 2, 31, 4, 11, 3, 23, 4, 5, 2,
  168.         15, 3, 25, 6, 6, 2, 19, 1, 29, 6,
  169.         10, 2, 22, 4, 3, 3, 14, 2, 24, 6,
  170.         6, 1, 17, 3, 28, 5, 8, 3, 20, 1,
  171.         32, 5, 12, 3, 22, 6, 4, 1, 16, 2,
  172.         26, 6, 6, 3, 17, 2, 0, 4, 10, 3,
  173.         22, 4, 3, 2, 14, 3, 24, 6, 5, 2,
  174.         17, 1, 28, 6, 9, 2, 19, 3, 31, 4,
  175.         13, 2, 23, 6, 3, 3, 15, 1, 27, 5,
  176.         7, 3, 17, 3, 29, 4, 11, 2, 21, 6,
  177.         3, 1, 14, 2, 25, 6, 5, 3, 16, 2,
  178.         28, 4, 9, 3, 20, 2, 0, 6, 12, 1,
  179.         23, 6, 4, 2, 14, 3, 26, 4, 8, 2,
  180.         18, 3, 0, 4, 10, 3, 21, 5, 1, 3,
  181.         13, 1, 24, 5, 5, 3, 15, 3, 27, 4,
  182.         8, 2, 19, 3, 29, 6, 10, 2, 22, 4,
  183.         3, 3, 14, 2, 26, 4, 6, 3, 18, 2,
  184.         28, 6, 10, 1, 20, 6, 2, 2, 12, 3,
  185.         24, 4, 5, 2, 16, 3, 28, 4, 8, 3,
  186.         19, 2, 0, 6, 12, 1, 23, 5, 3, 3,
  187.         14, 3, 26, 4, 7, 2, 17, 3, 28, 6,
  188.         9, 2, 21, 4, 1, 3, 13, 2, 25, 4,
  189.         5, 3, 16, 2, 27, 6, 9, 1, 19, 3,
  190.         0, 5, 11, 3, 23, 4, 4, 2, 14, 3,
  191.         25, 6, 7, 1, 18, 2, 28, 6, 9, 3,
  192.         21, 4, 2, 2, 12, 3, 25, 4, 6, 2,
  193.         16, 3, 26, 6, 8, 2, 20, 1, 0, 6,
  194.         11, 2, 22, 6, 4, 1, 15, 2, 25, 6,
  195.         6, 3, 18, 1, 29, 5, 9, 3, 22, 4,
  196.         2, 3, 13, 2, 23, 6, 4, 3, 15, 2,
  197.         27, 4, 7, 3, 19, 2, 31, 4, 11, 3,
  198.         21, 6, 3, 2, 15, 1, 25, 6, 6, 2,
  199.         17, 3, 29, 4, 10, 2, 20, 6, 3, 1,
  200.         13, 3, 24, 5, 4, 3, 16, 1, 27, 5,
  201.         7, 3, 17, 3, 0, 4, 11, 2, 21, 6,
  202.         1, 3, 13, 2, 25, 4, 5, 3, 16, 2,
  203.         29, 4, 9, 3, 19, 6, 30, 2, 13, 1,
  204.         23, 6, 4, 2, 14, 3, 27, 4, 8, 2,
  205.         18, 3, 0, 4, 11, 3, 22, 5, 2, 3,
  206.         14, 1, 26, 5, 6, 3, 16, 3, 28, 4,
  207.         10, 2, 20, 6, 30, 3, 11, 2, 24, 4,
  208.         4, 3, 15, 2, 25, 6, 8, 1, 19, 2,
  209.         29, 6, 9, 3, 22, 4, 3, 2, 13, 3,
  210.         25, 4, 7, 2, 17, 3, 27, 6, 9, 1,
  211.         21, 5, 1, 3, 11, 3, 23, 4, 5, 2,
  212.         15, 3, 25, 6, 6, 2, 19, 1, 29, 6,
  213.         10, 2, 22, 4, 3, 3, 14, 2, 24, 6,
  214.         6, 1, 18, 2, 28, 6, 8, 3, 20, 4,
  215.         2, 2, 12, 3, 24, 4, 4, 3, 16, 2,
  216.         26, 6, 6, 3, 17, 2, 0, 4, 10, 3,
  217.         22, 4, 3, 2, 14, 3, 24, 6, 5, 2,
  218.         17, 1, 28, 6, 9, 2, 21, 4, 1, 3,
  219.         13, 2, 23, 6, 5, 1, 15, 3, 27, 5,
  220.         7, 3, 19, 1, 0, 5, 10, 3, 22, 4,
  221.         2, 3, 13, 2, 24, 6, 4, 3, 15, 2,
  222.         27, 4, 8, 3, 20, 4, 1, 2, 11, 3,
  223.         22, 6, 3, 2, 15, 1, 25, 6, 7, 2,
  224.         17, 3, 29, 4, 10, 2, 21, 6, 1, 3,
  225.         13, 1, 24, 5, 5, 3, 15, 3, 27, 4,
  226.         8, 2, 19, 6, 1, 1, 12, 2, 22, 6,
  227.         3, 3, 14, 2, 26, 4, 6, 3, 18, 2,
  228.         28, 6, 10, 1, 20, 6, 2, 2, 12, 3,
  229.         24, 4, 5, 2, 16, 3, 28, 4, 9, 2,
  230.         19, 6, 30, 3, 12, 1, 23, 5, 3, 3,
  231.         14, 3, 26, 4, 7, 2, 17, 3, 28, 6,
  232.         9, 2, 21, 4, 1, 3, 13, 2, 25, 4,
  233.         5, 3, 16, 2, 27, 6, 9, 1, 19, 6,
  234.         30, 2, 11, 3, 23, 4, 4, 2, 14, 3,
  235.         27, 4, 7, 3, 18, 2, 28, 6, 11, 1,
  236.         22, 5, 2, 3, 12, 3, 25, 4, 6, 2,
  237.         16, 3, 26, 6, 8, 2, 20, 4, 30, 3,
  238.         11, 2, 24, 4, 4, 3, 15, 2, 25, 6,
  239.         8, 1, 18, 3, 29, 5, 9, 3, 22, 4,
  240.         3, 2, 13, 3, 23, 6, 6, 1, 17, 2,
  241.         27, 6, 7, 3, 20, 4, 1, 2, 11, 3,
  242.         23, 4, 5, 2, 15, 3, 25, 6, 6, 2,
  243.         19, 1, 29, 6, 10, 2, 20, 6, 3, 1,
  244.         14, 2, 24, 6, 4, 3, 17, 1, 28, 5,
  245.         8, 3, 20, 4, 1, 3, 12, 2, 22, 6,
  246.         2, 3, 14, 2, 26, 4, 6, 3, 17, 2,
  247.         0, 4, 10, 3, 20, 6, 1, 2, 14, 1,
  248.         24, 6, 5, 2, 15, 3, 28, 4, 9, 2,
  249.         19, 6, 1, 1, 12, 3, 23, 5, 3, 3,
  250.         15, 1, 27, 5, 7, 3, 17, 3, 29, 4,
  251.         11, 2, 21, 6, 1, 3, 12, 2, 25, 4,
  252.         5, 3, 16, 2, 28, 4, 9, 3, 19, 6,
  253.         30, 2, 12, 1, 23, 6, 4, 2, 14, 3,
  254.         26, 4, 8, 2, 18, 3, 0, 4, 10, 3,
  255.         22, 5, 2, 3, 14, 1, 25, 5, 6, 3,
  256.         16, 3, 28, 4, 9, 2, 20, 6, 30, 3,
  257.         11, 2, 23, 4, 4, 3, 15, 2, 27, 4,
  258.         7, 3, 19, 2, 29, 6, 11, 1, 21, 6,
  259.         3, 2, 13, 3, 25, 4, 6, 2, 17, 3,
  260.         27, 6, 9, 1, 20, 5, 30, 3, 10, 3,
  261.         22, 4, 3, 2, 14, 3, 24, 6, 5, 2,
  262.         17, 1, 28, 6, 9, 2, 21, 4, 1, 3,
  263.         13, 2, 23, 6, 5, 1, 16, 2, 27, 6,
  264.         7, 3, 19, 4, 30, 2, 11, 3, 23, 4,
  265.         3, 3, 14, 2, 25, 6, 5, 3, 16, 2,
  266.         28, 4, 9, 3, 21, 4, 2, 2, 12, 3,
  267.         23, 6, 4, 2, 16, 1, 26, 6, 8, 2,
  268.         20, 4, 30, 3, 11, 2, 22, 6, 4, 1,
  269.         14, 3, 25, 5, 6, 3, 18, 1, 29, 5,
  270.         9, 3, 22, 4, 2, 3, 13, 2, 23, 6,
  271.         4, 3, 15, 2, 27, 4, 7, 3, 20, 4,
  272.         1, 2, 11, 3, 21, 6, 3, 2, 15, 1,
  273.         25, 6, 6, 2, 17, 3, 29, 4, 10, 2,
  274.         20, 6, 3, 1, 13, 3, 24, 5, 4, 3,
  275.         17, 1, 28, 5, 8, 3, 18, 6, 1, 1,
  276.         12, 2, 22, 6, 2, 3, 14, 2, 26, 4,
  277.         6, 3, 17, 2, 28, 6, 10, 1, 20, 6,
  278.         1, 2, 12, 3, 24, 4, 5, 2, 15, 3,
  279.         28, 4, 9, 2, 19, 6, 33, 3, 12, 1,
  280.         23, 5, 3, 3, 13, 3, 25, 4, 6, 2,
  281.         16, 3, 26, 6, 8, 2, 20, 4, 30, 3,
  282.         11, 2, 24, 4, 4, 3, 15, 2, 25, 6,
  283.         8, 1, 18, 6, 33, 2, 9, 3, 22, 4,
  284.         3, 2, 13, 3, 25, 4, 6, 3, 17, 2,
  285.         27, 6, 9, 1, 21, 5, 1, 3, 11, 3,
  286.         23, 4, 5, 2, 15, 3, 25, 6, 6, 2,
  287.         19, 4, 33, 3, 10, 2, 22, 4, 3, 3,
  288.             // 1583-1584 (Hebrew year: 5343 - 5344)
  289.             // 1585-1589
  290.             // 1590-1594
  291.             // 1595-1599
  292.             // 1600
  293.             // 1605
  294.             // 1610
  295.             // 1615
  296.             // 1620
  297.             // 1625
  298.             // 1630
  299.             // 1635
  300.             // 1640
  301.             // 1645
  302.             // 1650
  303.             // 1655
  304.             // 1660
  305.             // 1665
  306.             // 1670
  307.             // 1675
  308.             // 1680
  309.             // 1685
  310.             // 1690
  311.             // 1695
  312.             // 1700
  313.             // 1705
  314.             // 1710
  315.             // 1715
  316.             // 1720
  317.             // 1725
  318.             // 1730
  319.             // 1735
  320.             // 1740
  321.             // 1745
  322.             // 1750
  323.             // 1755
  324.             // 1760
  325.             // 1765
  326.             // 1770
  327.             // 1775
  328.             // 1780
  329.             // 1785
  330.             // 1790
  331.             // 1795
  332.             // 1800
  333.             // 1805
  334.             // 1810
  335.             // 1815
  336.             // 1820
  337.             // 1825
  338.             // 1830
  339.             // 1835
  340.             // 1840
  341.             // 1845
  342.             // 1850
  343.             // 1855
  344.             // 1860
  345.             // 1865
  346.             // 1870
  347.             // 1875
  348.             // 1880
  349.             // 1885
  350.             // 1890
  351.             // 1895
  352.             // 1900
  353.             // 1905
  354.             // 1910
  355.             // 1915
  356.             // 1920
  357.             // 1925
  358.             // 1930
  359.             // 1935
  360.             // 1940
  361.             // 1945
  362.             // 1950
  363.             // 1955
  364.             // 1960
  365.             // 1965
  366.             // 1970
  367.             // 1975
  368.             // 1980
  369.             // 1985
  370.             // 1990
  371.             // 1995
  372.             // 2000 - 2004
  373.             // 2005 - 2009
  374.             // 2010
  375.             // 2015
  376.             // 2020
  377.             // 2025
  378.             // 2030
  379.             // 2035
  380.             // 2040
  381.             // 2045
  382.             // 2050
  383.             // 2055
  384.             // 2060
  385.             // 2065
  386.             // 2070
  387.             // 2075
  388.             // 2080
  389.             // 2085
  390.             // 2090
  391.             // 2095
  392.             // 2100
  393.             // 2105
  394.             // 2110
  395.             // 2115
  396.             // 2120
  397.             // 2125
  398.             // 2130
  399.             // 2135
  400.             // 2140
  401.             // 2145
  402.             // 2150
  403.             // 2155
  404.             // 2160
  405.             // 2165
  406.             // 2170
  407.             // 2175
  408.             // 2180
  409.             // 2185
  410.             // 2190
  411.             // 2195
  412.             // 2200
  413.             // 2205
  414.             // 2210
  415.             // 2215
  416.             // 2220
  417.             // 2225
  418.             // 2230
  419.             // 2235
  420.             // 2240 (Hebrew year: 6000)
  421.         14, 2, 24, 6, 6, 1};
  422.        
  423.         //
  424.         // The lunar calendar has 6 different variations of month lengths
  425.         // within a year.
  426.         //
  427.         private static readonly int[,] m_lunarMonthLen = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  428.         0, 0, 0, 0}, {0, 30, 29, 29, 29, 30, 29, 30, 29, 30,
  429.         29, 30, 29, 0}, {0, 30, 29, 30, 29, 30, 29, 30, 29, 30,
  430.         29, 30, 29, 0}, {0, 30, 30, 30, 29, 30, 29, 30, 29, 30,
  431.         29, 30, 29, 0}, {0, 30, 29, 29, 29, 30, 30, 29, 30, 29,
  432.         30, 29, 30, 29}, {0, 30, 29, 30, 29, 30, 30, 29, 30, 29,
  433.         30, 29, 30, 29}, {0, 30, 30, 30, 29, 30, 30, 29, 30, 29,
  434.             // 3 common year variations
  435.             // 3 leap year variations
  436.         30, 29, 30, 29}};
  437.        
  438.         //internal static Calendar m_defaultInstance;
  439.        
  440.         static internal readonly DateTime calendarMinValue = new DateTime(1583, 1, 1);
  441.         // Gregorian 2239/9/29 = Hebrew 5999/13/29 (last day in Hebrew year 5999).
  442.         // We can only format/parse Hebrew numbers up to 999, so we limit the max range to Hebrew year 5999.
  443.         static internal readonly DateTime calendarMaxValue = new DateTime((new DateTime(2239, 9, 29, 23, 59, 59, 999)).Ticks + 9999);
  444.        
  445.        
  446.        
  447.         public override DateTime MinSupportedDateTime {
  448.             get { return (calendarMinValue); }
  449.         }
  450.        
  451.        
  452.        
  453.         public override DateTime MaxSupportedDateTime {
  454.             get { return (calendarMaxValue); }
  455.         }
  456.        
  457.        
  458.         // Return the type of the Hebrew calendar.
  459.         //
  460.        
  461.        
  462.         public override CalendarAlgorithmType AlgorithmType {
  463.             get { return CalendarAlgorithmType.LunisolarCalendar; }
  464.         }
  465.        
  466. /*=================================GetDefaultInstance==========================
  467.         **Action: Internal method to provide a default intance of HebrewCalendar.  Used by NLS+ implementation
  468.         **      and other calendars.
  469.         **Returns:
  470.         **Arguments:
  471.         **Exceptions:
  472.         ============================================================================*/       
  473.        
  474. /*
  475.         internal static Calendar GetDefaultInstance() {
  476.             if (m_defaultInstance == null) {
  477.                 m_defaultInstance = new HebrewCalendar();
  478.             }
  479.             return (m_defaultInstance);
  480.         }
  481.         */       
  482.        
  483.        
  484.         // Construct an instance of gregorian calendar.
  485.        
  486.         public HebrewCalendar()
  487.         {
  488.         }
  489.        
  490.         internal override int ID {
  491.             get { return (CAL_HEBREW); }
  492.         }
  493.        
  494.        
  495. /*=================================CheckHebrewYearValue==========================
  496.         **Action: Check if the Hebrew year value is supported in this class.
  497.         **Returns:  None.
  498.         **Arguments: y  Hebrew year value
  499.         **          ear Hebrew era value
  500.         **Exceptions: ArgumentOutOfRange_Range if the year value is not supported.
  501.         **Note:
  502.         **  We use a table for the Hebrew calendar calculation, so the year supported is limited.
  503.         ============================================================================*/       
  504.        
  505.         private void CheckHebrewYearValue(int y, int era, string varName)
  506.         {
  507.             CheckEraRange(era);
  508.             if (y > m_maxHebrewYear || y < m_minHebrewYear) {
  509.                 throw new ArgumentOutOfRangeException(varName, String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), m_minHebrewYear, m_maxHebrewYear));
  510.             }
  511.         }
  512.        
  513. /*=================================CheckHebrewMonthValue==========================
  514.         **Action: Check if the Hebrew month value is valid.
  515.         **Returns:  None.
  516.         **Arguments: year  Hebrew year value
  517.         **          month Hebrew month value
  518.         **Exceptions: ArgumentOutOfRange_Range if the month value is not valid.
  519.         **Note:
  520.         **  Call CheckHebrewYearValue() before calling this to verify the year value is supported.
  521.         ============================================================================*/       
  522.        
  523.         private void CheckHebrewMonthValue(int year, int month, int era)
  524.         {
  525.             int monthsInYear = GetMonthsInYear(year, era);
  526.             if (month < 1 || month > monthsInYear) {
  527.                 throw new ArgumentOutOfRangeException("month", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), 1, monthsInYear));
  528.             }
  529.         }
  530.        
  531. /*=================================CheckHebrewDayValue==========================
  532.         **Action: Check if the Hebrew day value is valid.
  533.         **Returns:  None.
  534.         **Arguments: year  Hebrew year value
  535.         **          month Hebrew month value
  536.         **          day    Hebrew day value.
  537.         **Exceptions: ArgumentOutOfRange_Range if the day value is not valid.
  538.         **Note:
  539.         **  Call CheckHebrewYearValue()/CheckHebrewMonthValue() before calling this to verify the year/month values are valid.
  540.         ============================================================================*/       
  541.        
  542.         private void CheckHebrewDayValue(int year, int month, int day, int era)
  543.         {
  544.             int daysInMonth = GetDaysInMonth(year, month, era);
  545.             if (day < 1 || day > daysInMonth) {
  546.                 throw new ArgumentOutOfRangeException("day", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), 1, daysInMonth));
  547.             }
  548.         }
  549.        
  550.         internal void CheckEraRange(int era)
  551.         {
  552.             if (era != CurrentEra && era != HebrewEra) {
  553.                 throw new ArgumentOutOfRangeException("era", Environment.GetResourceString("ArgumentOutOfRange_InvalidEraValue"));
  554.             }
  555.         }
  556.        
  557.         private void CheckTicksRange(long ticks)
  558.         {
  559.             if (ticks < calendarMinValue.Ticks || ticks > calendarMaxValue.Ticks) {
  560.                     // Print out the date in Gregorian using InvariantCulture since the DateTime is based on GreograinCalendar.
  561.                 throw new ArgumentOutOfRangeException("time", String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("ArgumentOutOfRange_CalendarRange"), calendarMinValue, calendarMaxValue));
  562.             }
  563.         }
  564.        
  565.         internal int GetResult(__DateBuffer result, int part)
  566.         {
  567.             switch (part) {
  568.                 case DatePartYear:
  569.                     return (result.year);
  570.                 case DatePartMonth:
  571.                     return (result.month);
  572.                 case DatePartDay:
  573.                     return (result.day);
  574.             }
  575.            
  576.             throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_DateTimeParsing"));
  577.         }
  578.        
  579. /*=================================GetLunarMonthDay==========================
  580.         **Action: Using the Hebrew table (m_HebrewTable) to get the Hebrew month/day value for Gregorian January 1st
  581.         ** in a given Gregorian year.
  582.         ** Greogrian January 1st falls usually in Tevet (4th month). Tevet has always 29 days.
  583.         **    That's why, there no nead to specify the lunar month in the table.  There are exceptions, and these
  584.         **    are coded by giving numbers above 29 and below 1.
  585.         **    Actual decoding is takenig place in the switch statement below.
  586.         **Returns:
  587.         **    The Hebrew year type. The value is from 1 to 6.
  588.         **    normal years : 1 = 353 days  2 = 354 days  3 = 355 days.
  589.         **    Leap years  : 4 = 383        5  384        6 = 385 days.
  590.         **Arguments:
  591.         **      gregorianYear  The year value in Gregorian calendar.  The value should be between 1500 and 2239.
  592.         **      lunarDate      Object to take the result of the Hebrew year/month/day.
  593.         **Exceptions:
  594.         ============================================================================*/       
  595.        
  596.         internal int GetLunarMonthDay(int gregorianYear, __DateBuffer lunarDate)
  597.         {
  598.             //
  599.             // Get the offset into the m_lunarMonthLen array and the lunar day
  600.             // for January 1st.
  601.             //
  602.             int index = gregorianYear - FirstGregorianTableYear;
  603.             if (index < 0 || index > TABLESIZE) {
  604.                 throw new ArgumentOutOfRangeException("gregorianYear");
  605.             }
  606.            
  607.             index *= 2;
  608.             lunarDate.day = m_HebrewTable[index];
  609.            
  610.             // Get the type of the year. The value is from 1 to 6
  611.             int LunarYearType = m_HebrewTable[index + 1];
  612.            
  613.             //
  614.             // Get the Lunar Month.
  615.             //
  616.             switch (lunarDate.day) {
  617.                 case (0):
  618.                     // 1/1 is on Shvat 1
  619.                     lunarDate.month = 5;
  620.                     lunarDate.day = 1;
  621.                     break;
  622.                 case (30):
  623.                     // 1/1 is on Kislev 30
  624.                     lunarDate.month = 3;
  625.                     break;
  626.                 case (31):
  627.                     // 1/1 is on Shvat 2
  628.                     lunarDate.month = 5;
  629.                     lunarDate.day = 2;
  630.                     break;
  631.                 case (32):
  632.                     // 1/1 is on Shvat 3
  633.                     lunarDate.month = 5;
  634.                     lunarDate.day = 3;
  635.                     break;
  636.                 case (33):
  637.                     // 1/1 is on Kislev 29
  638.                     lunarDate.month = 3;
  639.                     lunarDate.day = 29;
  640.                     break;
  641.                 default:
  642.                     // 1/1 is on Tevet (This is the general case)
  643.                     lunarDate.month = 4;
  644.                     break;
  645.             }
  646.             return (LunarYearType);
  647.         }
  648.        
  649.         // Returns a given date part of this DateTime. This method is used
  650.         // to compute the year, day-of-year, month, or day part.
  651.        
  652.         internal virtual int GetDatePart(long ticks, int part)
  653.         {
  654.             // The Gregorian year, month, day value for ticks.
  655.             int gregorianYear;
  656.             int gregorianMonth;
  657.             int gregorianDay;
  658.             int hebrewYearType;
  659.             // lunar year type
  660.             long AbsoluteDate;
  661.             // absolute date - absolute date 1/1/1600
  662.             //
  663.             // Make sure we have a valid Gregorian date that will fit into our
  664.             // Hebrew conversion limits.
  665.             //
  666.             CheckTicksRange(ticks);
  667.            
  668.             DateTime time = new DateTime(ticks);
  669.            
  670.             //
  671.             // Save the Gregorian date values.
  672.             //
  673.             gregorianYear = time.Year;
  674.             gregorianMonth = time.Month;
  675.             gregorianDay = time.Day;
  676.            
  677.             __DateBuffer lunarDate = new __DateBuffer();
  678.             // lunar month and day for Jan 1
  679.             // From the table looking-up value of m_HebrewTable[index] (stored in lunarDate.day), we get the the
  680.             // lunar month and lunar day where the Gregorian date 1/1 falls.
  681.             lunarDate.year = gregorianYear + HebrewYearOf1AD;
  682.             hebrewYearType = GetLunarMonthDay(gregorianYear, lunarDate);
  683.            
  684.             // This is the buffer used to store the result Hebrew date.
  685.             __DateBuffer result = new __DateBuffer();
  686.            
  687.             //
  688.             // Store the values for the start of the new year - 1/1.
  689.             //
  690.             result.year = lunarDate.year;
  691.             result.month = lunarDate.month;
  692.             result.day = lunarDate.day;
  693.            
  694.             //
  695.             // Get the absolute date from 1/1/1600.
  696.             //
  697.             AbsoluteDate = GregorianCalendar.GetAbsoluteDate(gregorianYear, gregorianMonth, gregorianDay);
  698.            
  699.             //
  700.             // If the requested date was 1/1, then we're done.
  701.             //
  702.             if ((gregorianMonth == 1) && (gregorianDay == 1)) {
  703.                 return (GetResult(result, part));
  704.             }
  705.            
  706.             //
  707.             // Calculate the number of days between 1/1 and the requested date.
  708.             //
  709.             long NumDays;
  710.             // number of days since 1/1
  711.             NumDays = AbsoluteDate - GregorianCalendar.GetAbsoluteDate(gregorianYear, 1, 1);
  712.            
  713.             //
  714.             // If the requested date is within the current lunar month, then
  715.             // we're done.
  716.             //
  717.             if ((NumDays + (long)lunarDate.day) <= (long)(m_lunarMonthLen[hebrewYearType, lunarDate.month])) {
  718.                 result.day += (int)NumDays;
  719.                 return (GetResult(result, part));
  720.             }
  721.            
  722.             //
  723.             // Adjust for the current partial month.
  724.             //
  725.             result.month++;
  726.             result.day = 1;
  727.            
  728.             //
  729.             // Adjust the Lunar Month and Year (if necessary) based on the number
  730.             // of days between 1/1 and the requested date.
  731.             //
  732.             // Assumes Jan 1 can never translate to the last Lunar month, which
  733.             // is true.
  734.             //
  735.             NumDays -= (long)(m_lunarMonthLen[hebrewYearType, lunarDate.month] - lunarDate.day);
  736.             BCLDebug.Assert(NumDays >= 1, "NumDays >= 1");
  737.            
  738.             // If NumDays is 1, then we are done. Otherwise, find the correct Hebrew month
  739.             // and day.
  740.             if (NumDays > 1) {
  741.                 //
  742.                 // See if we're on the correct Lunar month.
  743.                 //
  744.                 while (NumDays > (long)(m_lunarMonthLen[hebrewYearType, result.month])) {
  745.                     //
  746.                     // Adjust the number of days and move to the next month.
  747.                     //
  748.                     NumDays -= (long)(m_lunarMonthLen[hebrewYearType, result.month++]);
  749.                    
  750.                     //
  751.                     // See if we need to adjust the Year.
  752.                     // Must handle both 12 and 13 month years.
  753.                     //
  754.                     if ((result.month > 13) || (m_lunarMonthLen[hebrewYearType, result.month] == 0)) {
  755.                         //
  756.                         // Adjust the Year.
  757.                         //
  758.                         result.year++;
  759.                         hebrewYearType = m_HebrewTable[(gregorianYear + 1 - FirstGregorianTableYear) * 2 + 1];
  760.                        
  761.                         //
  762.                         // Adjust the Month.
  763.                         //
  764.                         result.month = 1;
  765.                     }
  766.                 }
  767.                 //
  768.                 // Found the right Lunar month.
  769.                 //
  770.                 result.day += (int)(NumDays - 1);
  771.             }
  772.             return (GetResult(result, part));
  773.         }
  774.        
  775.         // Returns the DateTime resulting from adding the given number of
  776.         // months to the specified DateTime. The result is computed by incrementing
  777.         // (or decrementing) the year and month parts of the specified DateTime by
  778.         // value months, and, if required, adjusting the day part of the
  779.         // resulting date downwards to the last day of the resulting month in the
  780.         // resulting year. The time-of-day part of the result is the same as the
  781.         // time-of-day part of the specified DateTime.
  782.         //
  783.         // In more precise terms, considering the specified DateTime to be of the
  784.         // form y / m / d + t, where y is the
  785.         // year, m is the month, d is the day, and t is the
  786.         // time-of-day, the result is y1 / m1 / d1 + t,
  787.         // where y1 and m1 are computed by adding value months
  788.         // to y and m, and d1 is the largest value less than
  789.         // or equal to d that denotes a valid day in month m1 of year
  790.         // y1.
  791.         //
  792.        
  793.         public override DateTime AddMonths(DateTime time, int months)
  794.         {
  795.             try {
  796.                 int y = GetDatePart(time.Ticks, DatePartYear);
  797.                 int m = GetDatePart(time.Ticks, DatePartMonth);
  798.                 int d = GetDatePart(time.Ticks, DatePartDay);
  799.                
  800.                
  801.                 int monthsInYear;
  802.                 int i;
  803.                 if (months >= 0) {
  804.                     i = m + months;
  805.                     while (i > (monthsInYear = GetMonthsInYear(y, CurrentEra))) {
  806.                         y++;
  807.                         i -= monthsInYear;
  808.                     }
  809.                 }
  810.                 else {
  811.                     if ((i = m + months) <= 0) {
  812.                         months = -months;
  813.                         months -= m;
  814.                         y--;
  815.                        
  816.                         while (months > (monthsInYear = GetMonthsInYear(y, CurrentEra))) {
  817.                             y--;
  818.                             months -= monthsInYear;
  819.                         }
  820.                         monthsInYear = GetMonthsInYear(y, CurrentEra);
  821.                         i = monthsInYear - months;
  822.                     }
  823.                 }
  824.                
  825.                 int days = GetDaysInMonth(y, i);
  826.                 if (d > days) {
  827.                     d = days;
  828.                 }
  829.                 return (new DateTime(ToDateTime(y, i, d, 0, 0, 0, 0).Ticks + (time.Ticks % TicksPerDay)));
  830.             }
  831.             // We expect ArgumentException and ArgumentOutOfRangeException (which is subclass of ArgumentException)
  832.             // If exception is thrown in the calls above, we are out of the supported range of this calendar.
  833.             catch (ArgumentException) {
  834.                 throw new ArgumentOutOfRangeException("months", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_AddValue")));
  835.             }
  836.         }
  837.        
  838.         // Returns the DateTime resulting from adding the given number of
  839.         // years to the specified DateTime. The result is computed by incrementing
  840.         // (or decrementing) the year part of the specified DateTime by value
  841.         // years. If the month and day of the specified DateTime is 2/29, and if the
  842.         // resulting year is not a leap year, the month and day of the resulting
  843.         // DateTime becomes 2/28. Otherwise, the month, day, and time-of-day
  844.         // parts of the result are the same as those of the specified DateTime.
  845.         //
  846.        
  847.         public override DateTime AddYears(DateTime time, int years)
  848.         {
  849.             int y = GetDatePart(time.Ticks, DatePartYear);
  850.             int m = GetDatePart(time.Ticks, DatePartMonth);
  851.             int d = GetDatePart(time.Ticks, DatePartDay);
  852.            
  853.             y += years;
  854.             CheckHebrewYearValue(y, Calendar.CurrentEra, "years");
  855.            
  856.             int months = GetMonthsInYear(y, CurrentEra);
  857.             if (m > months) {
  858.                 m = months;
  859.             }
  860.            
  861.             int days = GetDaysInMonth(y, m);
  862.             if (d > days) {
  863.                 d = days;
  864.             }
  865.            
  866.             long ticks = ToDateTime(y, m, d, 0, 0, 0, 0).Ticks + (time.Ticks % TicksPerDay);
  867.             Calendar.CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
  868.             return (new DateTime(ticks));
  869.         }
  870.        
  871.         // Returns the day-of-month part of the specified DateTime. The returned
  872.         // value is an integer between 1 and 31.
  873.         //
  874.        
  875.         public override int GetDayOfMonth(DateTime time)
  876.         {
  877.             return (GetDatePart(time.Ticks, DatePartDay));
  878.         }
  879.        
  880.         // Returns the day-of-week part of the specified DateTime. The returned value
  881.         // is an integer between 0 and 6, where 0 indicates Sunday, 1 indicates
  882.         // Monday, 2 indicates Tuesday, 3 indicates Wednesday, 4 indicates
  883.         // Thursday, 5 indicates Friday, and 6 indicates Saturday.
  884.         //
  885.        
  886.         public override DayOfWeek GetDayOfWeek(DateTime time)
  887.         {
  888.             // If we calculate back, the Hebrew day of week for Gregorian 0001/1/1 is Monday (1).
  889.             // Therfore, the fomula is:
  890.             return ((DayOfWeek)((int)(time.Ticks / TicksPerDay + 1) % 7));
  891.         }
  892.        
  893.         internal int GetHebrewYearType(int year, int era)
  894.         {
  895.             CheckHebrewYearValue(year, era, "year");
  896.             // The m_HebrewTable is indexed by Gregorian year and starts from FirstGregorianYear.
  897.             // So we need to convert year (Hebrew year value) to Gregorian Year below.
  898.             return (m_HebrewTable[(year - HebrewYearOf1AD - FirstGregorianTableYear) * 2 + 1]);
  899.         }
  900.        
  901.         // Returns the day-of-year part of the specified DateTime. The returned value
  902.         // is an integer between 1 and 366.
  903.         //
  904.        
  905.         public override int GetDayOfYear(DateTime time)
  906.         {
  907.             // Get Hebrew year value of the specified time.
  908.             int year = GetYear(time);
  909.             DateTime beginOfYearDate = ToDateTime(year, 1, 1, 0, 0, 0, 0, CurrentEra);
  910.             return ((int)((time.Ticks - beginOfYearDate.Ticks) / TicksPerDay) + 1);
  911.         }
  912.        
  913.         // Returns the number of days in the month given by the year and
  914.         // month arguments.
  915.         //
  916.        
  917.         public override int GetDaysInMonth(int year, int month, int era)
  918.         {
  919.             CheckEraRange(era);
  920.             int hebrewYearType = GetHebrewYearType(year, era);
  921.             CheckHebrewMonthValue(year, month, era);
  922.            
  923.             BCLDebug.Assert(hebrewYearType >= 1 && hebrewYearType <= 6, "hebrewYearType should be from 1 to 6, but now hebrewYearType = " + hebrewYearType + " for hebrew year " + year);
  924.             int monthDays = m_lunarMonthLen[hebrewYearType, month];
  925.             if (monthDays == 0) {
  926.                 throw new ArgumentOutOfRangeException("month", Environment.GetResourceString("ArgumentOutOfRange_Month"));
  927.             }
  928.             return (monthDays);
  929.         }
  930.        
  931.         // Returns the number of days in the year given by the year argument for the current era.
  932.         //
  933.        
  934.         public override int GetDaysInYear(int year, int era)
  935.         {
  936.             CheckEraRange(era);
  937.             // normal years : 1 = 353 days 2 = 354 days 3 = 355 days.
  938.             // Leap years : 4 = 383 5 384 6 = 385 days.
  939.            
  940.             // LunarYearType is from 1 to 6
  941.             int LunarYearType = GetHebrewYearType(year, era);
  942.             if (LunarYearType < 4) {
  943.                 // common year: LunarYearType = 1, 2, 3
  944.                 return (352 + LunarYearType);
  945.             }
  946.             return (382 + (LunarYearType - 3));
  947.         }
  948.        
  949.         // Returns the era for the specified DateTime value.
  950.        
  951.         public override int GetEra(DateTime time)
  952.         {
  953.            
  954.             return (HebrewEra);
  955.         }
  956.        
  957.        
  958.         public override int[] Eras {
  959.             get { return (new int[] {HebrewEra}); }
  960.         }
  961.        
  962.         // Returns the month part of the specified DateTime. The returned value is an
  963.         // integer between 1 and 12.
  964.         //
  965.        
  966.         public override int GetMonth(DateTime time)
  967.         {
  968.             return (GetDatePart(time.Ticks, DatePartMonth));
  969.         }
  970.        
  971.         // Returns the number of months in the specified year and era.
  972.        
  973.         public override int GetMonthsInYear(int year, int era)
  974.         {
  975.             return (IsLeapYear(year, era) ? 13 : 12);
  976.         }
  977.        
  978.         // Returns the year part of the specified DateTime. The returned value is an
  979.         // integer between 1 and 9999.
  980.         //
  981.        
  982.         public override int GetYear(DateTime time)
  983.         {
  984.             return (GetDatePart(time.Ticks, DatePartYear));
  985.         }
  986.        
  987.         // Checks whether a given day in the specified era is a leap day. This method returns true if
  988.         // the date is a leap day, or false if not.
  989.         //
  990.        
  991.         public override bool IsLeapDay(int year, int month, int day, int era)
  992.         {
  993.             if (IsLeapMonth(year, month, era)) {
  994.                 // Every day in a leap month is a leap day.
  995.                 CheckHebrewDayValue(year, month, day, era);
  996.                 return (true);
  997.             }
  998.             else if (IsLeapYear(year, Calendar.CurrentEra)) {
  999.                 // There is an additional day in the 6th month in the leap year (the extra day is the 30th day in the 6th month),
  1000.                 // so we should return true for 6/30 if that's in a leap year.
  1001.                 if (month == 6 && day == 30) {
  1002.                     return (true);
  1003.                 }
  1004.             }
  1005.             CheckHebrewDayValue(year, month, day, era);
  1006.             return (false);
  1007.         }
  1008.        
  1009.         // Returns the leap month in a calendar year of the specified era. This method returns 0
  1010.         // if this calendar does not have leap month, or this year is not a leap year.
  1011.         //
  1012.        
  1013.        
  1014.         public override int GetLeapMonth(int year, int era)
  1015.         {
  1016.             // Year/era values are checked in IsLeapYear().
  1017.             if (IsLeapYear(year, era)) {
  1018.                 // The 7th month in a leap year is a leap month.
  1019.                 return (7);
  1020.             }
  1021.             return (0);
  1022.         }
  1023.        
  1024.         // Checks whether a given month in the specified era is a leap month. This method returns true if
  1025.         // month is a leap month, or false if not.
  1026.         //
  1027.        
  1028.         public override bool IsLeapMonth(int year, int month, int era)
  1029.         {
  1030.             // Year/era values are checked in IsLeapYear().
  1031.             bool isLeapYear = IsLeapYear(year, era);
  1032.             CheckHebrewMonthValue(year, month, era);
  1033.             // The 7th month in a leap year is a leap month.
  1034.             if (isLeapYear) {
  1035.                 if (month == 7) {
  1036.                     return (true);
  1037.                 }
  1038.             }
  1039.             return (false);
  1040.         }
  1041.        
  1042.         // Checks whether a given year in the specified era is a leap year. This method returns true if
  1043.         // year is a leap year, or false if not.
  1044.         //
  1045.        
  1046.         public override bool IsLeapYear(int year, int era)
  1047.         {
  1048.             CheckHebrewYearValue(year, era, "year");
  1049.             return (((7 * (long)year + 1) % 19) < 7);
  1050.         }
  1051.        
  1052.         // (month1, day1) - (month2, day2)
  1053.         int GetDayDifference(int lunarYearType, int month1, int day1, int month2, int day2)
  1054.         {
  1055.             if (month1 == month2) {
  1056.                 return (day1 - day2);
  1057.             }
  1058.            
  1059.             // Make sure that (month1, day1) < (month2, day2)
  1060.             bool swap = (month1 > month2);
  1061.             if (swap) {
  1062.                 // (month1, day1) < (month2, day2). Swap the values.
  1063.                 // The result will be a negative number.
  1064.                 int tempMonth;
  1065.                 int tempDay;
  1066.                 tempMonth = month1;
  1067.                 tempDay = day1;
  1068.                 month1 = month2;
  1069.                 day1 = day2;
  1070.                 month2 = tempMonth;
  1071.                 day2 = tempDay;
  1072.             }
  1073.            
  1074.             // Get the number of days from (month1,day1) to (month1, end of month1)
  1075.             int days = m_lunarMonthLen[lunarYearType, month1] - day1;
  1076.            
  1077.             // Move to next month.
  1078.             month1++;
  1079.            
  1080.             // Add up the days.
  1081.             while (month1 < month2) {
  1082.                 days += m_lunarMonthLen[lunarYearType, month1++];
  1083.             }
  1084.             days += day2;
  1085.            
  1086.             return (swap ? days : -days);
  1087.         }
  1088.        
  1089. /*=================================HebrewToGregorian==========================
  1090.         **Action: Convert Hebrew date to Gregorian date.
  1091.         **Returns:
  1092.         **Arguments:
  1093.         **Exceptions:
  1094.         **  The algorithm is like this:
  1095.         **      The hebrew year has an offset to the Gregorian year, so we can guess the Gregorian year for
  1096.         **      the specified Hebrew year.  That is, GreogrianYear = HebrewYear - FirstHebrewYearOf1AD.
  1097.         **
  1098.         **      From the Gregorian year and m_HebrewTable, we can get the Hebrew month/day value
  1099.         **      of the Gregorian date January 1st.  Let's call this month/day value [hebrewDateForJan1]
  1100.         **
  1101.         **      If the requested Hebrew month/day is less than [hebrewDateForJan1], we know the result
  1102.         **      Gregorian date falls in previous year.  So we decrease the Gregorian year value, and
  1103.         **      retrieve the Hebrew month/day value of the Gregorian date january 1st again.
  1104.         **
  1105.         **      Now, we get the answer of the Gregorian year.
  1106.         **
  1107.         **      The next step is to get the number of days between the requested Hebrew month/day
  1108.         **      and [hebrewDateForJan1].  When we get that, we can create the DateTime by adding/subtracting
  1109.         **      the ticks value of the number of days.
  1110.         **
  1111.         ============================================================================*/       
  1112.        
  1113.        
  1114.         DateTime HebrewToGregorian(int hebrewYear, int hebrewMonth, int hebrewDay, int hour, int minute, int second, int millisecond)
  1115.         {
  1116.             // Get the rough Gregorian year for the specified hebrewYear.
  1117.             //
  1118.             int gregorianYear = hebrewYear - HebrewYearOf1AD;
  1119.            
  1120.             __DateBuffer hebrewDateOfJan1 = new __DateBuffer();
  1121.             // year value is unused.
  1122.             int lunarYearType = GetLunarMonthDay(gregorianYear, hebrewDateOfJan1);
  1123.            
  1124.             if ((hebrewMonth == hebrewDateOfJan1.month) && (hebrewDay == hebrewDateOfJan1.day)) {
  1125.                 return (new DateTime(gregorianYear, 1, 1, hour, minute, second, millisecond));
  1126.             }
  1127.            
  1128.             int days = GetDayDifference(lunarYearType, hebrewMonth, hebrewDay, hebrewDateOfJan1.month, hebrewDateOfJan1.day);
  1129.            
  1130.             DateTime gregorianNewYear = new DateTime(gregorianYear, 1, 1);
  1131.             return (new DateTime(gregorianNewYear.Ticks + days * TicksPerDay + TimeToTicks(hour, minute, second, millisecond)));
  1132.         }
  1133.        
  1134.         // Returns the date and time converted to a DateTime value. Throws an exception if the n-tuple is invalid.
  1135.         //
  1136.        
  1137.         public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
  1138.         {
  1139.             CheckHebrewYearValue(year, era, "year");
  1140.             CheckHebrewMonthValue(year, month, era);
  1141.             CheckHebrewDayValue(year, month, day, era);
  1142.             DateTime dt = HebrewToGregorian(year, month, day, hour, minute, second, millisecond);
  1143.             CheckTicksRange(dt.Ticks);
  1144.             return (dt);
  1145.         }
  1146.        
  1147.         private const int DEFAULT_TWO_DIGIT_YEAR_MAX = 5790;
  1148.        
  1149.        
  1150.         public override int TwoDigitYearMax {
  1151.             get {
  1152.                 if (twoDigitYearMax == -1) {
  1153.                     twoDigitYearMax = GetSystemTwoDigitYearSetting(ID, DEFAULT_TWO_DIGIT_YEAR_MAX);
  1154.                 }
  1155.                 return (twoDigitYearMax);
  1156.             }
  1157.            
  1158.             set {
  1159.                 VerifyWritable();
  1160.                 if (value == 99) {
  1161.                     // Do nothing here. Year 99 is allowed so that TwoDitYearMax is disabled.
  1162.                 }
  1163.                 else {
  1164.                     CheckHebrewYearValue(value, HebrewEra, "value");
  1165.                 }
  1166.                 twoDigitYearMax = value;
  1167.             }
  1168.         }
  1169.        
  1170.        
  1171.         public override int ToFourDigitYear(int year)
  1172.         {
  1173.             if (year < 100) {
  1174.                 return (base.ToFourDigitYear(year));
  1175.             }
  1176.            
  1177.             if (year > m_maxHebrewYear || year < m_minHebrewYear) {
  1178.                 throw new ArgumentOutOfRangeException("year", String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_Range"), m_minHebrewYear, m_maxHebrewYear));
  1179.             }
  1180.             return (year);
  1181.         }
  1182.        
  1183.         internal class __DateBuffer
  1184.         {
  1185.             internal int year;
  1186.             internal int month;
  1187.             internal int day;
  1188.         }
  1189.        
  1190.     }
  1191.    
  1192. }

Developer Fusion