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