1/*
2******************************************************************************
3* Copyright (C) 2003-2013, International Business Machines Corporation
4* and others. All Rights Reserved.
5******************************************************************************
6*
7* File HEBRWCAL.CPP
8*
9* Modification History:
10*
11*   Date        Name        Description
12*   12/03/2003  srl         ported from java HebrewCalendar
13*****************************************************************************
14*/
15
16#include "hebrwcal.h"
17
18#if !UCONFIG_NO_FORMATTING
19
20#include "umutex.h"
21#include <float.h>
22#include "gregoimp.h" // Math
23#include "astro.h" // CalendarAstronomer
24#include "uhash.h"
25#include "ucln_in.h"
26
27// Hebrew Calendar implementation
28
29/**
30* The absolute date, in milliseconds since 1/1/1970 AD, Gregorian,
31* of the start of the Hebrew calendar.  In order to keep this calendar's
32* time of day in sync with that of the Gregorian calendar, we use
33* midnight, rather than sunset the day before.
34*/
35//static const double EPOCH_MILLIS = -180799862400000.; // 1/1/1 HY
36
37static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = {
38    // Minimum  Greatest    Least  Maximum
39    //           Minimum  Maximum
40    {        0,        0,        0,        0}, // ERA
41    { -5000000, -5000000,  5000000,  5000000}, // YEAR
42    {        0,        0,       12,       12}, // MONTH
43    {        1,        1,       51,       56}, // WEEK_OF_YEAR
44    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // WEEK_OF_MONTH
45    {        1,        1,       29,       30}, // DAY_OF_MONTH
46    {        1,        1,      353,      385}, // DAY_OF_YEAR
47    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DAY_OF_WEEK
48    {       -1,       -1,        5,        5}, // DAY_OF_WEEK_IN_MONTH
49    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // AM_PM
50    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR
51    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR_OF_DAY
52    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MINUTE
53    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // SECOND
54    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECOND
55    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // ZONE_OFFSET
56    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DST_OFFSET
57    { -5000000, -5000000,  5000000,  5000000}, // YEAR_WOY
58    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DOW_LOCAL
59    { -5000000, -5000000,  5000000,  5000000}, // EXTENDED_YEAR
60    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // JULIAN_DAY
61    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECONDS_IN_DAY
62    {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // IS_LEAP_MONTH
63};
64
65/**
66* The lengths of the Hebrew months.  This is complicated, because there
67* are three different types of years, or six if you count leap years.
68* Due to the rules for postponing the start of the year to avoid having
69* certain holidays fall on the sabbath, the year can end up being three
70* different lengths, called "deficient", "normal", and "complete".
71*/
72static const int8_t MONTH_LENGTH[][3] = {
73    // Deficient  Normal     Complete
74    {   30,         30,         30     },           //Tishri
75    {   29,         29,         30     },           //Heshvan
76    {   29,         30,         30     },           //Kislev
77    {   29,         29,         29     },           //Tevet
78    {   30,         30,         30     },           //Shevat
79    {   30,         30,         30     },           //Adar I (leap years only)
80    {   29,         29,         29     },           //Adar
81    {   30,         30,         30     },           //Nisan
82    {   29,         29,         29     },           //Iyar
83    {   30,         30,         30     },           //Sivan
84    {   29,         29,         29     },           //Tammuz
85    {   30,         30,         30     },           //Av
86    {   29,         29,         29     },           //Elul
87};
88
89/**
90* The cumulative # of days to the end of each month in a non-leap year
91* Although this can be calculated from the MONTH_LENGTH table,
92* keeping it around separately makes some calculations a lot faster
93*/
94
95static const int16_t MONTH_START[][3] = {
96    // Deficient  Normal     Complete
97    {    0,          0,          0  },          // (placeholder)
98    {   30,         30,         30  },          // Tishri
99    {   59,         59,         60  },          // Heshvan
100    {   88,         89,         90  },          // Kislev
101    {  117,        118,        119  },          // Tevet
102    {  147,        148,        149  },          // Shevat
103    {  147,        148,        149  },          // (Adar I placeholder)
104    {  176,        177,        178  },          // Adar
105    {  206,        207,        208  },          // Nisan
106    {  235,        236,        237  },          // Iyar
107    {  265,        266,        267  },          // Sivan
108    {  294,        295,        296  },          // Tammuz
109    {  324,        325,        326  },          // Av
110    {  353,        354,        355  },          // Elul
111};
112
113/**
114* The cumulative # of days to the end of each month in a leap year
115*/
116static const int16_t  LEAP_MONTH_START[][3] = {
117    // Deficient  Normal     Complete
118    {    0,          0,          0  },          // (placeholder)
119    {   30,         30,         30  },          // Tishri
120    {   59,         59,         60  },          // Heshvan
121    {   88,         89,         90  },          // Kislev
122    {  117,        118,        119  },          // Tevet
123    {  147,        148,        149  },          // Shevat
124    {  177,        178,        179  },          // Adar I
125    {  206,        207,        208  },          // Adar II
126    {  236,        237,        238  },          // Nisan
127    {  265,        266,        267  },          // Iyar
128    {  295,        296,        297  },          // Sivan
129    {  324,        325,        326  },          // Tammuz
130    {  354,        355,        356  },          // Av
131    {  383,        384,        385  },          // Elul
132};
133
134static icu::CalendarCache *gCache =  NULL;
135
136U_CDECL_BEGIN
137static UBool calendar_hebrew_cleanup(void) {
138    delete gCache;
139    gCache = NULL;
140    return TRUE;
141}
142U_CDECL_END
143
144U_NAMESPACE_BEGIN
145//-------------------------------------------------------------------------
146// Constructors...
147//-------------------------------------------------------------------------
148
149/**
150* Constructs a default <code>HebrewCalendar</code> using the current time
151* in the default time zone with the default locale.
152* @internal
153*/
154HebrewCalendar::HebrewCalendar(const Locale& aLocale, UErrorCode& success)
155:   Calendar(TimeZone::createDefault(), aLocale, success)
156
157{
158    setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
159}
160
161
162HebrewCalendar::~HebrewCalendar() {
163}
164
165const char *HebrewCalendar::getType() const {
166    return "hebrew";
167}
168
169Calendar* HebrewCalendar::clone() const {
170    return new HebrewCalendar(*this);
171}
172
173HebrewCalendar::HebrewCalendar(const HebrewCalendar& other) : Calendar(other) {
174}
175
176
177//-------------------------------------------------------------------------
178// Rolling and adding functions overridden from Calendar
179//
180// These methods call through to the default implementation in IBMCalendar
181// for most of the fields and only handle the unusual ones themselves.
182//-------------------------------------------------------------------------
183
184/**
185* Add a signed amount to a specified field, using this calendar's rules.
186* For example, to add three days to the current date, you can call
187* <code>add(Calendar.DATE, 3)</code>.
188* <p>
189* When adding to certain fields, the values of other fields may conflict and
190* need to be changed.  For example, when adding one to the {@link #MONTH MONTH} field
191* for the date "30 Av 5758", the {@link #DAY_OF_MONTH DAY_OF_MONTH} field
192* must be adjusted so that the result is "29 Elul 5758" rather than the invalid
193* "30 Elul 5758".
194* <p>
195* This method is able to add to
196* all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET},
197* and {@link #ZONE_OFFSET ZONE_OFFSET}.
198* <p>
199* <b>Note:</b> You should always use {@link #roll roll} and add rather
200* than attempting to perform arithmetic operations directly on the fields
201* of a <tt>HebrewCalendar</tt>.  Since the {@link #MONTH MONTH} field behaves
202* discontinuously in non-leap years, simple arithmetic can give invalid results.
203* <p>
204* @param field     the time field.
205* @param amount    the amount to add to the field.
206*
207* @exception   IllegalArgumentException if the field is invalid or refers
208*              to a field that cannot be handled by this method.
209* @internal
210*/
211void HebrewCalendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status)
212{
213    if(U_FAILURE(status)) {
214        return;
215    }
216    switch (field) {
217  case UCAL_MONTH:
218      {
219          // We can't just do a set(MONTH, get(MONTH) + amount).  The
220          // reason is ADAR_1.  Suppose amount is +2 and we land in
221          // ADAR_1 -- then we have to bump to ADAR_2 aka ADAR.  But
222          // if amount is -2 and we land in ADAR_1, then we have to
223          // bump the other way -- down to SHEVAT.  - Alan 11/00
224          int32_t month = get(UCAL_MONTH, status);
225          int32_t year = get(UCAL_YEAR, status);
226          UBool acrossAdar1;
227          if (amount > 0) {
228              acrossAdar1 = (month < ADAR_1); // started before ADAR_1?
229              month += amount;
230              for (;;) {
231                  if (acrossAdar1 && month>=ADAR_1 && !isLeapYear(year)) {
232                      ++month;
233                  }
234                  if (month <= ELUL) {
235                      break;
236                  }
237                  month -= ELUL+1;
238                  ++year;
239                  acrossAdar1 = TRUE;
240              }
241          } else {
242              acrossAdar1 = (month > ADAR_1); // started after ADAR_1?
243              month += amount;
244              for (;;) {
245                  if (acrossAdar1 && month<=ADAR_1 && !isLeapYear(year)) {
246                      --month;
247                  }
248                  if (month >= 0) {
249                      break;
250                  }
251                  month += ELUL+1;
252                  --year;
253                  acrossAdar1 = TRUE;
254              }
255          }
256          set(UCAL_MONTH, month);
257          set(UCAL_YEAR, year);
258          pinField(UCAL_DAY_OF_MONTH, status);
259          break;
260      }
261
262  default:
263      Calendar::add(field, amount, status);
264      break;
265    }
266}
267
268/**
269* @deprecated ICU 2.6 use UCalendarDateFields instead of EDateFields
270*/
271void HebrewCalendar::add(EDateFields field, int32_t amount, UErrorCode& status)
272{
273    add((UCalendarDateFields)field, amount, status);
274}
275
276/**
277* Rolls (up/down) a specified amount time on the given field.  For
278* example, to roll the current date up by three days, you can call
279* <code>roll(Calendar.DATE, 3)</code>.  If the
280* field is rolled past its maximum allowable value, it will "wrap" back
281* to its minimum and continue rolling.
282* For example, calling <code>roll(Calendar.DATE, 10)</code>
283* on a Hebrew calendar set to "25 Av 5758" will result in the date "5 Av 5758".
284* <p>
285* When rolling certain fields, the values of other fields may conflict and
286* need to be changed.  For example, when rolling the {@link #MONTH MONTH} field
287* upward by one for the date "30 Av 5758", the {@link #DAY_OF_MONTH DAY_OF_MONTH} field
288* must be adjusted so that the result is "29 Elul 5758" rather than the invalid
289* "30 Elul".
290* <p>
291* This method is able to roll
292* all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET},
293* and {@link #ZONE_OFFSET ZONE_OFFSET}.  Subclasses may, of course, add support for
294* additional fields in their overrides of <code>roll</code>.
295* <p>
296* <b>Note:</b> You should always use roll and {@link #add add} rather
297* than attempting to perform arithmetic operations directly on the fields
298* of a <tt>HebrewCalendar</tt>.  Since the {@link #MONTH MONTH} field behaves
299* discontinuously in non-leap years, simple arithmetic can give invalid results.
300* <p>
301* @param field     the time field.
302* @param amount    the amount by which the field should be rolled.
303*
304* @exception   IllegalArgumentException if the field is invalid or refers
305*              to a field that cannot be handled by this method.
306* @internal
307*/
308void HebrewCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status)
309{
310    if(U_FAILURE(status)) {
311        return;
312    }
313    switch (field) {
314  case UCAL_MONTH:
315      {
316          int32_t month = get(UCAL_MONTH, status);
317          int32_t year = get(UCAL_YEAR, status);
318
319          UBool leapYear = isLeapYear(year);
320          int32_t yearLength = monthsInYear(year);
321          int32_t newMonth = month + (amount % yearLength);
322          //
323          // If it's not a leap year and we're rolling past the missing month
324          // of ADAR_1, we need to roll an extra month to make up for it.
325          //
326          if (!leapYear) {
327              if (amount > 0 && month < ADAR_1 && newMonth >= ADAR_1) {
328                  newMonth++;
329              } else if (amount < 0 && month > ADAR_1 && newMonth <= ADAR_1) {
330                  newMonth--;
331              }
332          }
333          set(UCAL_MONTH, (newMonth + 13) % 13);
334          pinField(UCAL_DAY_OF_MONTH, status);
335          return;
336      }
337  default:
338      Calendar::roll(field, amount, status);
339    }
340}
341
342void HebrewCalendar::roll(EDateFields field, int32_t amount, UErrorCode& status) {
343    roll((UCalendarDateFields)field, amount, status);
344}
345
346//-------------------------------------------------------------------------
347// Support methods
348//-------------------------------------------------------------------------
349
350// Hebrew date calculations are performed in terms of days, hours, and
351// "parts" (or halakim), which are 1/1080 of an hour, or 3 1/3 seconds.
352static const int32_t HOUR_PARTS = 1080;
353static const int32_t DAY_PARTS  = 24*HOUR_PARTS;
354
355// An approximate value for the length of a lunar month.
356// It is used to calculate the approximate year and month of a given
357// absolute date.
358static const int32_t  MONTH_DAYS = 29;
359static const int32_t MONTH_FRACT = 12*HOUR_PARTS + 793;
360static const int32_t MONTH_PARTS = MONTH_DAYS*DAY_PARTS + MONTH_FRACT;
361
362// The time of the new moon (in parts) on 1 Tishri, year 1 (the epoch)
363// counting from noon on the day before.  BAHARAD is an abbreviation of
364// Bet (Monday), Hey (5 hours from sunset), Resh-Daled (204).
365static const int32_t BAHARAD = 11*HOUR_PARTS + 204;
366
367/**
368* Finds the day # of the first day in the given Hebrew year.
369* To do this, we want to calculate the time of the Tishri 1 new moon
370* in that year.
371* <p>
372* The algorithm here is similar to ones described in a number of
373* references, including:
374* <ul>
375* <li>"Calendrical Calculations", by Nachum Dershowitz & Edward Reingold,
376*     Cambridge University Press, 1997, pages 85-91.
377*
378* <li>Hebrew Calendar Science and Myths,
379*     <a href="http://www.geocities.com/Athens/1584/">
380*     http://www.geocities.com/Athens/1584/</a>
381*
382* <li>The Calendar FAQ,
383*      <a href="http://www.faqs.org/faqs/calendars/faq/">
384*      http://www.faqs.org/faqs/calendars/faq/</a>
385* </ul>
386*/
387int32_t HebrewCalendar::startOfYear(int32_t year, UErrorCode &status)
388{
389    ucln_i18n_registerCleanup(UCLN_I18N_HEBREW_CALENDAR, calendar_hebrew_cleanup);
390    int32_t day = CalendarCache::get(&gCache, year, status);
391
392    if (day == 0) {
393        int32_t months = (235 * year - 234) / 19;           // # of months before year
394
395        int64_t frac = (int64_t)months * MONTH_FRACT + BAHARAD;  // Fractional part of day #
396        day  = months * 29 + (int32_t)(frac / DAY_PARTS);        // Whole # part of calculation
397        frac = frac % DAY_PARTS;                        // Time of day
398
399        int32_t wd = (day % 7);                        // Day of week (0 == Monday)
400
401        if (wd == 2 || wd == 4 || wd == 6) {
402            // If the 1st is on Sun, Wed, or Fri, postpone to the next day
403            day += 1;
404            wd = (day % 7);
405        }
406        if (wd == 1 && frac > 15*HOUR_PARTS+204 && !isLeapYear(year) ) {
407            // If the new moon falls after 3:11:20am (15h204p from the previous noon)
408            // on a Tuesday and it is not a leap year, postpone by 2 days.
409            // This prevents 356-day years.
410            day += 2;
411        }
412        else if (wd == 0 && frac > 21*HOUR_PARTS+589 && isLeapYear(year-1) ) {
413            // If the new moon falls after 9:32:43 1/3am (21h589p from yesterday noon)
414            // on a Monday and *last* year was a leap year, postpone by 1 day.
415            // Prevents 382-day years.
416            day += 1;
417        }
418        CalendarCache::put(&gCache, year, day, status);
419    }
420    return day;
421}
422
423/**
424* Find the day of the week for a given day
425*
426* @param day   The # of days since the start of the Hebrew calendar,
427*              1-based (i.e. 1/1/1 AM is day 1).
428*/
429int32_t HebrewCalendar::absoluteDayToDayOfWeek(int32_t day)
430{
431    // We know that 1/1/1 AM is a Monday, which makes the math easy...
432    return (day % 7) + 1;
433}
434
435/**
436* Returns the the type of a given year.
437*  0   "Deficient" year with 353 or 383 days
438*  1   "Normal"    year with 354 or 384 days
439*  2   "Complete"  year with 355 or 385 days
440*/
441int32_t HebrewCalendar::yearType(int32_t year) const
442{
443    int32_t yearLength = handleGetYearLength(year);
444
445    if (yearLength > 380) {
446        yearLength -= 30;        // Subtract length of leap month.
447    }
448
449    int type = 0;
450
451    switch (yearLength) {
452  case 353:
453      type = 0; break;
454  case 354:
455      type = 1; break;
456  case 355:
457      type = 2; break;
458  default:
459      //throw new RuntimeException("Illegal year length " + yearLength + " in year " + year);
460      type = 1;
461    }
462    return type;
463}
464
465/**
466* Determine whether a given Hebrew year is a leap year
467*
468* The rule here is that if (year % 19) == 0, 3, 6, 8, 11, 14, or 17.
469* The formula below performs the same test, believe it or not.
470*/
471UBool HebrewCalendar::isLeapYear(int32_t year) {
472    //return (year * 12 + 17) % 19 >= 12;
473    int32_t x = (year*12 + 17) % 19;
474    return x >= ((x < 0) ? -7 : 12);
475}
476
477int32_t HebrewCalendar::monthsInYear(int32_t year) {
478    return isLeapYear(year) ? 13 : 12;
479}
480
481//-------------------------------------------------------------------------
482// Calendar framework
483//-------------------------------------------------------------------------
484
485/**
486* @internal
487*/
488int32_t HebrewCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const {
489    return LIMITS[field][limitType];
490}
491
492/**
493* Returns the length of the given month in the given year
494* @internal
495*/
496int32_t HebrewCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const {
497    // Resolve out-of-range months.  This is necessary in order to
498    // obtain the correct year.  We correct to
499    // a 12- or 13-month year (add/subtract 12 or 13, depending
500    // on the year) but since we _always_ number from 0..12, and
501    // the leap year determines whether or not month 5 (Adar 1)
502    // is present, we allow 0..12 in any given year.
503    while (month < 0) {
504        month += monthsInYear(--extendedYear);
505    }
506    // Careful: allow 0..12 in all years
507    while (month > 12) {
508        month -= monthsInYear(extendedYear++);
509    }
510
511    switch (month) {
512    case HESHVAN:
513    case KISLEV:
514      // These two month lengths can vary
515      return MONTH_LENGTH[month][yearType(extendedYear)];
516
517    default:
518      // The rest are a fixed length
519      return MONTH_LENGTH[month][0];
520    }
521}
522
523/**
524* Returns the number of days in the given Hebrew year
525* @internal
526*/
527int32_t HebrewCalendar::handleGetYearLength(int32_t eyear) const {
528    UErrorCode status = U_ZERO_ERROR;
529    return startOfYear(eyear+1, status) - startOfYear(eyear, status);
530}
531
532void HebrewCalendar::validateField(UCalendarDateFields field, UErrorCode &status) {
533    if (field == UCAL_MONTH && !isLeapYear(handleGetExtendedYear()) && internalGet(UCAL_MONTH) == ADAR_1) {
534        status = U_ILLEGAL_ARGUMENT_ERROR;
535        return;
536    }
537    Calendar::validateField(field, status);
538}
539//-------------------------------------------------------------------------
540// Functions for converting from milliseconds to field values
541//-------------------------------------------------------------------------
542
543/**
544* Subclasses may override this method to compute several fields
545* specific to each calendar system.  These are:
546*
547* <ul><li>ERA
548* <li>YEAR
549* <li>MONTH
550* <li>DAY_OF_MONTH
551* <li>DAY_OF_YEAR
552* <li>EXTENDED_YEAR</ul>
553*
554* Subclasses can refer to the DAY_OF_WEEK and DOW_LOCAL fields,
555* which will be set when this method is called.  Subclasses can
556* also call the getGregorianXxx() methods to obtain Gregorian
557* calendar equivalents for the given Julian day.
558*
559* <p>In addition, subclasses should compute any subclass-specific
560* fields, that is, fields from BASE_FIELD_COUNT to
561* getFieldCount() - 1.
562* @internal
563*/
564void HebrewCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
565    int32_t d = julianDay - 347997;
566    double m = ((d * (double)DAY_PARTS)/ (double) MONTH_PARTS);         // Months (approx)
567    int32_t year = (int32_t)( ((19. * m + 234.) / 235.) + 1.);     // Years (approx)
568    int32_t ys  = startOfYear(year, status);                   // 1st day of year
569    int32_t dayOfYear = (d - ys);
570
571    // Because of the postponement rules, it's possible to guess wrong.  Fix it.
572    while (dayOfYear < 1) {
573        year--;
574        ys  = startOfYear(year, status);
575        dayOfYear = (d - ys);
576    }
577
578    // Now figure out which month we're in, and the date within that month
579    int32_t type = yearType(year);
580    UBool isLeap = isLeapYear(year);
581
582    int32_t month = 0;
583    int32_t momax = sizeof(MONTH_START) / (3 * sizeof(MONTH_START[0][0]));
584    while (month < momax && dayOfYear > (  isLeap ? LEAP_MONTH_START[month][type] : MONTH_START[month][type] ) ) {
585        month++;
586    }
587    if (month >= momax || month<=0) {
588        // TODO: I found dayOfYear could be out of range when
589        // a large value is set to julianDay.  I patched startOfYear
590        // to reduce the chace, but it could be still reproduced either
591        // by startOfYear or other places.  For now, we check
592        // the month is in valid range to avoid out of array index
593        // access problem here.  However, we need to carefully review
594        // the calendar implementation to check the extreme limit of
595        // each calendar field and the code works well for any values
596        // in the valid value range.  -yoshito
597        status = U_ILLEGAL_ARGUMENT_ERROR;
598        return;
599    }
600    month--;
601    int dayOfMonth = dayOfYear - (isLeap ? LEAP_MONTH_START[month][type] : MONTH_START[month][type]);
602
603    internalSet(UCAL_ERA, 0);
604    internalSet(UCAL_YEAR, year);
605    internalSet(UCAL_EXTENDED_YEAR, year);
606    internalSet(UCAL_MONTH, month);
607    internalSet(UCAL_DAY_OF_MONTH, dayOfMonth);
608    internalSet(UCAL_DAY_OF_YEAR, dayOfYear);
609}
610
611//-------------------------------------------------------------------------
612// Functions for converting from field values to milliseconds
613//-------------------------------------------------------------------------
614
615/**
616* @internal
617*/
618int32_t HebrewCalendar::handleGetExtendedYear() {
619    int32_t year;
620    if (newerField(UCAL_EXTENDED_YEAR, UCAL_YEAR) == UCAL_EXTENDED_YEAR) {
621        year = internalGet(UCAL_EXTENDED_YEAR, 1); // Default to year 1
622    } else {
623        year = internalGet(UCAL_YEAR, 1); // Default to year 1
624    }
625    return year;
626}
627
628/**
629* Return JD of start of given month/year.
630* @internal
631*/
632int32_t HebrewCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const {
633    UErrorCode status = U_ZERO_ERROR;
634    // Resolve out-of-range months.  This is necessary in order to
635    // obtain the correct year.  We correct to
636    // a 12- or 13-month year (add/subtract 12 or 13, depending
637    // on the year) but since we _always_ number from 0..12, and
638    // the leap year determines whether or not month 5 (Adar 1)
639    // is present, we allow 0..12 in any given year.
640    while (month < 0) {
641        month += monthsInYear(--eyear);
642    }
643    // Careful: allow 0..12 in all years
644    while (month > 12) {
645        month -= monthsInYear(eyear++);
646    }
647
648    int32_t day = startOfYear(eyear, status);
649
650    if(U_FAILURE(status)) {
651        return 0;
652    }
653
654    if (month != 0) {
655        if (isLeapYear(eyear)) {
656            day += LEAP_MONTH_START[month][yearType(eyear)];
657        } else {
658            day += MONTH_START[month][yearType(eyear)];
659        }
660    }
661
662    return (int) (day + 347997);
663}
664
665UBool
666HebrewCalendar::inDaylightTime(UErrorCode& status) const
667{
668    // copied from GregorianCalendar
669    if (U_FAILURE(status) || !getTimeZone().useDaylightTime())
670        return FALSE;
671
672    // Force an update of the state of the Calendar.
673    ((HebrewCalendar*)this)->complete(status); // cast away const
674
675    return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE);
676}
677
678/**
679 * The system maintains a static default century start date and Year.  They are
680 * initialized the first time they are used.  Once the system default century date
681 * and year are set, they do not change.
682 */
683static UDate           gSystemDefaultCenturyStart       = DBL_MIN;
684static int32_t         gSystemDefaultCenturyStartYear   = -1;
685static icu::UInitOnce  gSystemDefaultCenturyInit        = U_INITONCE_INITIALIZER;
686
687UBool HebrewCalendar::haveDefaultCentury() const
688{
689    return TRUE;
690}
691
692static void U_CALLCONV initializeSystemDefaultCentury()
693{
694    // initialize systemDefaultCentury and systemDefaultCenturyYear based
695    // on the current time.  They'll be set to 80 years before
696    // the current time.
697    UErrorCode status = U_ZERO_ERROR;
698    HebrewCalendar calendar(Locale("@calendar=hebrew"),status);
699    if (U_SUCCESS(status)) {
700        calendar.setTime(Calendar::getNow(), status);
701        calendar.add(UCAL_YEAR, -80, status);
702
703        gSystemDefaultCenturyStart = calendar.getTime(status);
704        gSystemDefaultCenturyStartYear = calendar.get(UCAL_YEAR, status);
705    }
706    // We have no recourse upon failure unless we want to propagate the failure
707    // out.
708}
709
710
711UDate HebrewCalendar::defaultCenturyStart() const {
712    // lazy-evaluate systemDefaultCenturyStart
713    umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
714    return gSystemDefaultCenturyStart;
715}
716
717int32_t HebrewCalendar::defaultCenturyStartYear() const {
718    // lazy-evaluate systemDefaultCenturyStartYear
719    umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
720    return gSystemDefaultCenturyStartYear;
721}
722
723
724UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HebrewCalendar)
725
726U_NAMESPACE_END
727
728#endif // UCONFIG_NO_FORMATTING
729
730