1 // Copyright (C) 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 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 */ 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 165 HebrewCalendar::~HebrewCalendar() { 166 } 167 168 const char *HebrewCalendar::getType() const { 169 return "hebrew"; 170 } 171 172 Calendar* HebrewCalendar::clone() const { 173 return new HebrewCalendar(*this); 174 } 175 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 444 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 */ 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 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 */ 491 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 */ 499 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 */ 530 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 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 */ 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 */ 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 */ 635 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 669 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 690 UBool HebrewCalendar::haveDefaultCentury() const 691 { 692 return TRUE; 693 } 694 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 714 UDate HebrewCalendar::defaultCenturyStart() const { 715 // lazy-evaluate systemDefaultCenturyStart 716 umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury); 717 return gSystemDefaultCenturyStart; 718 } 719 720 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
