| /* | |
| ****************************************************************************** | |
| * Copyright (C) 2003-2013, International Business Machines Corporation | |
| * and others. All Rights Reserved. | |
| ****************************************************************************** | |
| * | |
| * File HEBRWCAL.CPP | |
| * | |
| * Modification History: | |
| * | |
| * Date Name Description | |
| * 12/03/2003 srl ported from java HebrewCalendar | |
| ***************************************************************************** | |
| */ | |
| #include "hebrwcal.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "umutex.h" | |
| #include <float.h> | |
| #include "gregoimp.h" // Math | |
| #include "astro.h" // CalendarAstronomer | |
| #include "uhash.h" | |
| #include "ucln_in.h" | |
| // Hebrew Calendar implementation | |
| /** | |
| * The absolute date, in milliseconds since 1/1/1970 AD, Gregorian, | |
| * of the start of the Hebrew calendar. In order to keep this calendar's | |
| * time of day in sync with that of the Gregorian calendar, we use | |
| * midnight, rather than sunset the day before. | |
| */ | |
| //static const double EPOCH_MILLIS = -180799862400000.; // 1/1/1 HY | |
| static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = { | |
| // Minimum Greatest Least Maximum | |
| // Minimum Maximum | |
| { 0, 0, 0, 0}, // ERA | |
| { -5000000, -5000000, 5000000, 5000000}, // YEAR | |
| { 0, 0, 12, 12}, // MONTH | |
| { 1, 1, 51, 56}, // WEEK_OF_YEAR | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // WEEK_OF_MONTH | |
| { 1, 1, 29, 30}, // DAY_OF_MONTH | |
| { 1, 1, 353, 385}, // DAY_OF_YEAR | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DAY_OF_WEEK | |
| { -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // AM_PM | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR_OF_DAY | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MINUTE | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // SECOND | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECOND | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // ZONE_OFFSET | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DST_OFFSET | |
| { -5000000, -5000000, 5000000, 5000000}, // YEAR_WOY | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DOW_LOCAL | |
| { -5000000, -5000000, 5000000, 5000000}, // EXTENDED_YEAR | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // JULIAN_DAY | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECONDS_IN_DAY | |
| {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // IS_LEAP_MONTH | |
| }; | |
| /** | |
| * The lengths of the Hebrew months. This is complicated, because there | |
| * are three different types of years, or six if you count leap years. | |
| * Due to the rules for postponing the start of the year to avoid having | |
| * certain holidays fall on the sabbath, the year can end up being three | |
| * different lengths, called "deficient", "normal", and "complete". | |
| */ | |
| static const int8_t MONTH_LENGTH[][3] = { | |
| // Deficient Normal Complete | |
| { 30, 30, 30 }, //Tishri | |
| { 29, 29, 30 }, //Heshvan | |
| { 29, 30, 30 }, //Kislev | |
| { 29, 29, 29 }, //Tevet | |
| { 30, 30, 30 }, //Shevat | |
| { 30, 30, 30 }, //Adar I (leap years only) | |
| { 29, 29, 29 }, //Adar | |
| { 30, 30, 30 }, //Nisan | |
| { 29, 29, 29 }, //Iyar | |
| { 30, 30, 30 }, //Sivan | |
| { 29, 29, 29 }, //Tammuz | |
| { 30, 30, 30 }, //Av | |
| { 29, 29, 29 }, //Elul | |
| }; | |
| /** | |
| * The cumulative # of days to the end of each month in a non-leap year | |
| * Although this can be calculated from the MONTH_LENGTH table, | |
| * keeping it around separately makes some calculations a lot faster | |
| */ | |
| static const int16_t MONTH_START[][3] = { | |
| // Deficient Normal Complete | |
| { 0, 0, 0 }, // (placeholder) | |
| { 30, 30, 30 }, // Tishri | |
| { 59, 59, 60 }, // Heshvan | |
| { 88, 89, 90 }, // Kislev | |
| { 117, 118, 119 }, // Tevet | |
| { 147, 148, 149 }, // Shevat | |
| { 147, 148, 149 }, // (Adar I placeholder) | |
| { 176, 177, 178 }, // Adar | |
| { 206, 207, 208 }, // Nisan | |
| { 235, 236, 237 }, // Iyar | |
| { 265, 266, 267 }, // Sivan | |
| { 294, 295, 296 }, // Tammuz | |
| { 324, 325, 326 }, // Av | |
| { 353, 354, 355 }, // Elul | |
| }; | |
| /** | |
| * The cumulative # of days to the end of each month in a leap year | |
| */ | |
| static const int16_t LEAP_MONTH_START[][3] = { | |
| // Deficient Normal Complete | |
| { 0, 0, 0 }, // (placeholder) | |
| { 30, 30, 30 }, // Tishri | |
| { 59, 59, 60 }, // Heshvan | |
| { 88, 89, 90 }, // Kislev | |
| { 117, 118, 119 }, // Tevet | |
| { 147, 148, 149 }, // Shevat | |
| { 177, 178, 179 }, // Adar I | |
| { 206, 207, 208 }, // Adar II | |
| { 236, 237, 238 }, // Nisan | |
| { 265, 266, 267 }, // Iyar | |
| { 295, 296, 297 }, // Sivan | |
| { 324, 325, 326 }, // Tammuz | |
| { 354, 355, 356 }, // Av | |
| { 383, 384, 385 }, // Elul | |
| }; | |
| static icu::CalendarCache *gCache = NULL; | |
| U_CDECL_BEGIN | |
| static UBool calendar_hebrew_cleanup(void) { | |
| delete gCache; | |
| gCache = NULL; | |
| return TRUE; | |
| } | |
| U_CDECL_END | |
| U_NAMESPACE_BEGIN | |
| //------------------------------------------------------------------------- | |
| // Constructors... | |
| //------------------------------------------------------------------------- | |
| /** | |
| * Constructs a default <code>HebrewCalendar</code> using the current time | |
| * in the default time zone with the default locale. | |
| * @internal | |
| */ | |
| HebrewCalendar::HebrewCalendar(const Locale& aLocale, UErrorCode& success) | |
| : Calendar(TimeZone::createDefault(), aLocale, success) | |
| { | |
| setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. | |
| } | |
| HebrewCalendar::~HebrewCalendar() { | |
| } | |
| const char *HebrewCalendar::getType() const { | |
| return "hebrew"; | |
| } | |
| Calendar* HebrewCalendar::clone() const { | |
| return new HebrewCalendar(*this); | |
| } | |
| HebrewCalendar::HebrewCalendar(const HebrewCalendar& other) : Calendar(other) { | |
| } | |
| //------------------------------------------------------------------------- | |
| // Rolling and adding functions overridden from Calendar | |
| // | |
| // These methods call through to the default implementation in IBMCalendar | |
| // for most of the fields and only handle the unusual ones themselves. | |
| //------------------------------------------------------------------------- | |
| /** | |
| * Add a signed amount to a specified field, using this calendar's rules. | |
| * For example, to add three days to the current date, you can call | |
| * <code>add(Calendar.DATE, 3)</code>. | |
| * <p> | |
| * When adding to certain fields, the values of other fields may conflict and | |
| * need to be changed. For example, when adding one to the {@link #MONTH MONTH} field | |
| * for the date "30 Av 5758", the {@link #DAY_OF_MONTH DAY_OF_MONTH} field | |
| * must be adjusted so that the result is "29 Elul 5758" rather than the invalid | |
| * "30 Elul 5758". | |
| * <p> | |
| * This method is able to add to | |
| * all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET}, | |
| * and {@link #ZONE_OFFSET ZONE_OFFSET}. | |
| * <p> | |
| * <b>Note:</b> You should always use {@link #roll roll} and add rather | |
| * than attempting to perform arithmetic operations directly on the fields | |
| * of a <tt>HebrewCalendar</tt>. Since the {@link #MONTH MONTH} field behaves | |
| * discontinuously in non-leap years, simple arithmetic can give invalid results. | |
| * <p> | |
| * @param field the time field. | |
| * @param amount the amount to add to the field. | |
| * | |
| * @exception IllegalArgumentException if the field is invalid or refers | |
| * to a field that cannot be handled by this method. | |
| * @internal | |
| */ | |
| void HebrewCalendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status) | |
| { | |
| if(U_FAILURE(status)) { | |
| return; | |
| } | |
| switch (field) { | |
| case UCAL_MONTH: | |
| { | |
| // We can't just do a set(MONTH, get(MONTH) + amount). The | |
| // reason is ADAR_1. Suppose amount is +2 and we land in | |
| // ADAR_1 -- then we have to bump to ADAR_2 aka ADAR. But | |
| // if amount is -2 and we land in ADAR_1, then we have to | |
| // bump the other way -- down to SHEVAT. - Alan 11/00 | |
| int32_t month = get(UCAL_MONTH, status); | |
| int32_t year = get(UCAL_YEAR, status); | |
| UBool acrossAdar1; | |
| if (amount > 0) { | |
| acrossAdar1 = (month < ADAR_1); // started before ADAR_1? | |
| month += amount; | |
| for (;;) { | |
| if (acrossAdar1 && month>=ADAR_1 && !isLeapYear(year)) { | |
| ++month; | |
| } | |
| if (month <= ELUL) { | |
| break; | |
| } | |
| month -= ELUL+1; | |
| ++year; | |
| acrossAdar1 = TRUE; | |
| } | |
| } else { | |
| acrossAdar1 = (month > ADAR_1); // started after ADAR_1? | |
| month += amount; | |
| for (;;) { | |
| if (acrossAdar1 && month<=ADAR_1 && !isLeapYear(year)) { | |
| --month; | |
| } | |
| if (month >= 0) { | |
| break; | |
| } | |
| month += ELUL+1; | |
| --year; | |
| acrossAdar1 = TRUE; | |
| } | |
| } | |
| set(UCAL_MONTH, month); | |
| set(UCAL_YEAR, year); | |
| pinField(UCAL_DAY_OF_MONTH, status); | |
| break; | |
| } | |
| default: | |
| Calendar::add(field, amount, status); | |
| break; | |
| } | |
| } | |
| /** | |
| * @deprecated ICU 2.6 use UCalendarDateFields instead of EDateFields | |
| */ | |
| void HebrewCalendar::add(EDateFields field, int32_t amount, UErrorCode& status) | |
| { | |
| add((UCalendarDateFields)field, amount, status); | |
| } | |
| /** | |
| * Rolls (up/down) a specified amount time on the given field. For | |
| * example, to roll the current date up by three days, you can call | |
| * <code>roll(Calendar.DATE, 3)</code>. If the | |
| * field is rolled past its maximum allowable value, it will "wrap" back | |
| * to its minimum and continue rolling. | |
| * For example, calling <code>roll(Calendar.DATE, 10)</code> | |
| * on a Hebrew calendar set to "25 Av 5758" will result in the date "5 Av 5758". | |
| * <p> | |
| * When rolling certain fields, the values of other fields may conflict and | |
| * need to be changed. For example, when rolling the {@link #MONTH MONTH} field | |
| * upward by one for the date "30 Av 5758", the {@link #DAY_OF_MONTH DAY_OF_MONTH} field | |
| * must be adjusted so that the result is "29 Elul 5758" rather than the invalid | |
| * "30 Elul". | |
| * <p> | |
| * This method is able to roll | |
| * all fields except for {@link #ERA ERA}, {@link #DST_OFFSET DST_OFFSET}, | |
| * and {@link #ZONE_OFFSET ZONE_OFFSET}. Subclasses may, of course, add support for | |
| * additional fields in their overrides of <code>roll</code>. | |
| * <p> | |
| * <b>Note:</b> You should always use roll and {@link #add add} rather | |
| * than attempting to perform arithmetic operations directly on the fields | |
| * of a <tt>HebrewCalendar</tt>. Since the {@link #MONTH MONTH} field behaves | |
| * discontinuously in non-leap years, simple arithmetic can give invalid results. | |
| * <p> | |
| * @param field the time field. | |
| * @param amount the amount by which the field should be rolled. | |
| * | |
| * @exception IllegalArgumentException if the field is invalid or refers | |
| * to a field that cannot be handled by this method. | |
| * @internal | |
| */ | |
| void HebrewCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) | |
| { | |
| if(U_FAILURE(status)) { | |
| return; | |
| } | |
| switch (field) { | |
| case UCAL_MONTH: | |
| { | |
| int32_t month = get(UCAL_MONTH, status); | |
| int32_t year = get(UCAL_YEAR, status); | |
| UBool leapYear = isLeapYear(year); | |
| int32_t yearLength = monthsInYear(year); | |
| int32_t newMonth = month + (amount % yearLength); | |
| // | |
| // If it's not a leap year and we're rolling past the missing month | |
| // of ADAR_1, we need to roll an extra month to make up for it. | |
| // | |
| if (!leapYear) { | |
| if (amount > 0 && month < ADAR_1 && newMonth >= ADAR_1) { | |
| newMonth++; | |
| } else if (amount < 0 && month > ADAR_1 && newMonth <= ADAR_1) { | |
| newMonth--; | |
| } | |
| } | |
| set(UCAL_MONTH, (newMonth + 13) % 13); | |
| pinField(UCAL_DAY_OF_MONTH, status); | |
| return; | |
| } | |
| default: | |
| Calendar::roll(field, amount, status); | |
| } | |
| } | |
| void HebrewCalendar::roll(EDateFields field, int32_t amount, UErrorCode& status) { | |
| roll((UCalendarDateFields)field, amount, status); | |
| } | |
| //------------------------------------------------------------------------- | |
| // Support methods | |
| //------------------------------------------------------------------------- | |
| // Hebrew date calculations are performed in terms of days, hours, and | |
| // "parts" (or halakim), which are 1/1080 of an hour, or 3 1/3 seconds. | |
| static const int32_t HOUR_PARTS = 1080; | |
| static const int32_t DAY_PARTS = 24*HOUR_PARTS; | |
| // An approximate value for the length of a lunar month. | |
| // It is used to calculate the approximate year and month of a given | |
| // absolute date. | |
| static const int32_t MONTH_DAYS = 29; | |
| static const int32_t MONTH_FRACT = 12*HOUR_PARTS + 793; | |
| static const int32_t MONTH_PARTS = MONTH_DAYS*DAY_PARTS + MONTH_FRACT; | |
| // The time of the new moon (in parts) on 1 Tishri, year 1 (the epoch) | |
| // counting from noon on the day before. BAHARAD is an abbreviation of | |
| // Bet (Monday), Hey (5 hours from sunset), Resh-Daled (204). | |
| static const int32_t BAHARAD = 11*HOUR_PARTS + 204; | |
| /** | |
| * Finds the day # of the first day in the given Hebrew year. | |
| * To do this, we want to calculate the time of the Tishri 1 new moon | |
| * in that year. | |
| * <p> | |
| * The algorithm here is similar to ones described in a number of | |
| * references, including: | |
| * <ul> | |
| * <li>"Calendrical Calculations", by Nachum Dershowitz & Edward Reingold, | |
| * Cambridge University Press, 1997, pages 85-91. | |
| * | |
| * <li>Hebrew Calendar Science and Myths, | |
| * <a href="http://www.geocities.com/Athens/1584/"> | |
| * http://www.geocities.com/Athens/1584/</a> | |
| * | |
| * <li>The Calendar FAQ, | |
| * <a href="http://www.faqs.org/faqs/calendars/faq/"> | |
| * http://www.faqs.org/faqs/calendars/faq/</a> | |
| * </ul> | |
| */ | |
| int32_t HebrewCalendar::startOfYear(int32_t year, UErrorCode &status) | |
| { | |
| ucln_i18n_registerCleanup(UCLN_I18N_HEBREW_CALENDAR, calendar_hebrew_cleanup); | |
| int32_t day = CalendarCache::get(&gCache, year, status); | |
| if (day == 0) { | |
| int32_t months = (235 * year - 234) / 19; // # of months before year | |
| int64_t frac = (int64_t)months * MONTH_FRACT + BAHARAD; // Fractional part of day # | |
| day = months * 29 + (int32_t)(frac / DAY_PARTS); // Whole # part of calculation | |
| frac = frac % DAY_PARTS; // Time of day | |
| int32_t wd = (day % 7); // Day of week (0 == Monday) | |
| if (wd == 2 || wd == 4 || wd == 6) { | |
| // If the 1st is on Sun, Wed, or Fri, postpone to the next day | |
| day += 1; | |
| wd = (day % 7); | |
| } | |
| if (wd == 1 && frac > 15*HOUR_PARTS+204 && !isLeapYear(year) ) { | |
| // If the new moon falls after 3:11:20am (15h204p from the previous noon) | |
| // on a Tuesday and it is not a leap year, postpone by 2 days. | |
| // This prevents 356-day years. | |
| day += 2; | |
| } | |
| else if (wd == 0 && frac > 21*HOUR_PARTS+589 && isLeapYear(year-1) ) { | |
| // If the new moon falls after 9:32:43 1/3am (21h589p from yesterday noon) | |
| // on a Monday and *last* year was a leap year, postpone by 1 day. | |
| // Prevents 382-day years. | |
| day += 1; | |
| } | |
| CalendarCache::put(&gCache, year, day, status); | |
| } | |
| return day; | |
| } | |
| /** | |
| * Find the day of the week for a given day | |
| * | |
| * @param day The # of days since the start of the Hebrew calendar, | |
| * 1-based (i.e. 1/1/1 AM is day 1). | |
| */ | |
| int32_t HebrewCalendar::absoluteDayToDayOfWeek(int32_t day) | |
| { | |
| // We know that 1/1/1 AM is a Monday, which makes the math easy... | |
| return (day % 7) + 1; | |
| } | |
| /** | |
| * Returns the the type of a given year. | |
| * 0 "Deficient" year with 353 or 383 days | |
| * 1 "Normal" year with 354 or 384 days | |
| * 2 "Complete" year with 355 or 385 days | |
| */ | |
| int32_t HebrewCalendar::yearType(int32_t year) const | |
| { | |
| int32_t yearLength = handleGetYearLength(year); | |
| if (yearLength > 380) { | |
| yearLength -= 30; // Subtract length of leap month. | |
| } | |
| int type = 0; | |
| switch (yearLength) { | |
| case 353: | |
| type = 0; break; | |
| case 354: | |
| type = 1; break; | |
| case 355: | |
| type = 2; break; | |
| default: | |
| //throw new RuntimeException("Illegal year length " + yearLength + " in year " + year); | |
| type = 1; | |
| } | |
| return type; | |
| } | |
| /** | |
| * Determine whether a given Hebrew year is a leap year | |
| * | |
| * The rule here is that if (year % 19) == 0, 3, 6, 8, 11, 14, or 17. | |
| * The formula below performs the same test, believe it or not. | |
| */ | |
| UBool HebrewCalendar::isLeapYear(int32_t year) { | |
| //return (year * 12 + 17) % 19 >= 12; | |
| int32_t x = (year*12 + 17) % 19; | |
| return x >= ((x < 0) ? -7 : 12); | |
| } | |
| int32_t HebrewCalendar::monthsInYear(int32_t year) { | |
| return isLeapYear(year) ? 13 : 12; | |
| } | |
| //------------------------------------------------------------------------- | |
| // Calendar framework | |
| //------------------------------------------------------------------------- | |
| /** | |
| * @internal | |
| */ | |
| int32_t HebrewCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const { | |
| return LIMITS[field][limitType]; | |
| } | |
| /** | |
| * Returns the length of the given month in the given year | |
| * @internal | |
| */ | |
| int32_t HebrewCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const { | |
| // Resolve out-of-range months. This is necessary in order to | |
| // obtain the correct year. We correct to | |
| // a 12- or 13-month year (add/subtract 12 or 13, depending | |
| // on the year) but since we _always_ number from 0..12, and | |
| // the leap year determines whether or not month 5 (Adar 1) | |
| // is present, we allow 0..12 in any given year. | |
| while (month < 0) { | |
| month += monthsInYear(--extendedYear); | |
| } | |
| // Careful: allow 0..12 in all years | |
| while (month > 12) { | |
| month -= monthsInYear(extendedYear++); | |
| } | |
| switch (month) { | |
| case HESHVAN: | |
| case KISLEV: | |
| // These two month lengths can vary | |
| return MONTH_LENGTH[month][yearType(extendedYear)]; | |
| default: | |
| // The rest are a fixed length | |
| return MONTH_LENGTH[month][0]; | |
| } | |
| } | |
| /** | |
| * Returns the number of days in the given Hebrew year | |
| * @internal | |
| */ | |
| int32_t HebrewCalendar::handleGetYearLength(int32_t eyear) const { | |
| UErrorCode status = U_ZERO_ERROR; | |
| return startOfYear(eyear+1, status) - startOfYear(eyear, status); | |
| } | |
| void HebrewCalendar::validateField(UCalendarDateFields field, UErrorCode &status) { | |
| if (field == UCAL_MONTH && !isLeapYear(handleGetExtendedYear()) && internalGet(UCAL_MONTH) == ADAR_1) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| Calendar::validateField(field, status); | |
| } | |
| //------------------------------------------------------------------------- | |
| // Functions for converting from milliseconds to field values | |
| //------------------------------------------------------------------------- | |
| /** | |
| * Subclasses may override this method to compute several fields | |
| * specific to each calendar system. These are: | |
| * | |
| * <ul><li>ERA | |
| * <li>YEAR | |
| * <li>MONTH | |
| * <li>DAY_OF_MONTH | |
| * <li>DAY_OF_YEAR | |
| * <li>EXTENDED_YEAR</ul> | |
| * | |
| * Subclasses can refer to the DAY_OF_WEEK and DOW_LOCAL fields, | |
| * which will be set when this method is called. Subclasses can | |
| * also call the getGregorianXxx() methods to obtain Gregorian | |
| * calendar equivalents for the given Julian day. | |
| * | |
| * <p>In addition, subclasses should compute any subclass-specific | |
| * fields, that is, fields from BASE_FIELD_COUNT to | |
| * getFieldCount() - 1. | |
| * @internal | |
| */ | |
| void HebrewCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) { | |
| int32_t d = julianDay - 347997; | |
| double m = ((d * (double)DAY_PARTS)/ (double) MONTH_PARTS); // Months (approx) | |
| int32_t year = (int32_t)( ((19. * m + 234.) / 235.) + 1.); // Years (approx) | |
| int32_t ys = startOfYear(year, status); // 1st day of year | |
| int32_t dayOfYear = (d - ys); | |
| // Because of the postponement rules, it's possible to guess wrong. Fix it. | |
| while (dayOfYear < 1) { | |
| year--; | |
| ys = startOfYear(year, status); | |
| dayOfYear = (d - ys); | |
| } | |
| // Now figure out which month we're in, and the date within that month | |
| int32_t type = yearType(year); | |
| UBool isLeap = isLeapYear(year); | |
| int32_t month = 0; | |
| int32_t momax = sizeof(MONTH_START) / (3 * sizeof(MONTH_START[0][0])); | |
| while (month < momax && dayOfYear > ( isLeap ? LEAP_MONTH_START[month][type] : MONTH_START[month][type] ) ) { | |
| month++; | |
| } | |
| if (month >= momax || month<=0) { | |
| // TODO: I found dayOfYear could be out of range when | |
| // a large value is set to julianDay. I patched startOfYear | |
| // to reduce the chace, but it could be still reproduced either | |
| // by startOfYear or other places. For now, we check | |
| // the month is in valid range to avoid out of array index | |
| // access problem here. However, we need to carefully review | |
| // the calendar implementation to check the extreme limit of | |
| // each calendar field and the code works well for any values | |
| // in the valid value range. -yoshito | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| month--; | |
| int dayOfMonth = dayOfYear - (isLeap ? LEAP_MONTH_START[month][type] : MONTH_START[month][type]); | |
| internalSet(UCAL_ERA, 0); | |
| internalSet(UCAL_YEAR, year); | |
| internalSet(UCAL_EXTENDED_YEAR, year); | |
| internalSet(UCAL_MONTH, month); | |
| internalSet(UCAL_DAY_OF_MONTH, dayOfMonth); | |
| internalSet(UCAL_DAY_OF_YEAR, dayOfYear); | |
| } | |
| //------------------------------------------------------------------------- | |
| // Functions for converting from field values to milliseconds | |
| //------------------------------------------------------------------------- | |
| /** | |
| * @internal | |
| */ | |
| int32_t HebrewCalendar::handleGetExtendedYear() { | |
| int32_t year; | |
| if (newerField(UCAL_EXTENDED_YEAR, UCAL_YEAR) == UCAL_EXTENDED_YEAR) { | |
| year = internalGet(UCAL_EXTENDED_YEAR, 1); // Default to year 1 | |
| } else { | |
| year = internalGet(UCAL_YEAR, 1); // Default to year 1 | |
| } | |
| return year; | |
| } | |
| /** | |
| * Return JD of start of given month/year. | |
| * @internal | |
| */ | |
| int32_t HebrewCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /*useMonth*/) const { | |
| UErrorCode status = U_ZERO_ERROR; | |
| // Resolve out-of-range months. This is necessary in order to | |
| // obtain the correct year. We correct to | |
| // a 12- or 13-month year (add/subtract 12 or 13, depending | |
| // on the year) but since we _always_ number from 0..12, and | |
| // the leap year determines whether or not month 5 (Adar 1) | |
| // is present, we allow 0..12 in any given year. | |
| while (month < 0) { | |
| month += monthsInYear(--eyear); | |
| } | |
| // Careful: allow 0..12 in all years | |
| while (month > 12) { | |
| month -= monthsInYear(eyear++); | |
| } | |
| int32_t day = startOfYear(eyear, status); | |
| if(U_FAILURE(status)) { | |
| return 0; | |
| } | |
| if (month != 0) { | |
| if (isLeapYear(eyear)) { | |
| day += LEAP_MONTH_START[month][yearType(eyear)]; | |
| } else { | |
| day += MONTH_START[month][yearType(eyear)]; | |
| } | |
| } | |
| return (int) (day + 347997); | |
| } | |
| UBool | |
| HebrewCalendar::inDaylightTime(UErrorCode& status) const | |
| { | |
| // copied from GregorianCalendar | |
| if (U_FAILURE(status) || !getTimeZone().useDaylightTime()) | |
| return FALSE; | |
| // Force an update of the state of the Calendar. | |
| ((HebrewCalendar*)this)->complete(status); // cast away const | |
| return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE); | |
| } | |
| /** | |
| * The system maintains a static default century start date and Year. They are | |
| * initialized the first time they are used. Once the system default century date | |
| * and year are set, they do not change. | |
| */ | |
| static UDate gSystemDefaultCenturyStart = DBL_MIN; | |
| static int32_t gSystemDefaultCenturyStartYear = -1; | |
| static icu::UInitOnce gSystemDefaultCenturyInit = U_INITONCE_INITIALIZER; | |
| UBool HebrewCalendar::haveDefaultCentury() const | |
| { | |
| return TRUE; | |
| } | |
| static void U_CALLCONV initializeSystemDefaultCentury() | |
| { | |
| // initialize systemDefaultCentury and systemDefaultCenturyYear based | |
| // on the current time. They'll be set to 80 years before | |
| // the current time. | |
| UErrorCode status = U_ZERO_ERROR; | |
| HebrewCalendar calendar(Locale("@calendar=hebrew"),status); | |
| if (U_SUCCESS(status)) { | |
| calendar.setTime(Calendar::getNow(), status); | |
| calendar.add(UCAL_YEAR, -80, status); | |
| gSystemDefaultCenturyStart = calendar.getTime(status); | |
| gSystemDefaultCenturyStartYear = calendar.get(UCAL_YEAR, status); | |
| } | |
| // We have no recourse upon failure unless we want to propagate the failure | |
| // out. | |
| } | |
| UDate HebrewCalendar::defaultCenturyStart() const { | |
| // lazy-evaluate systemDefaultCenturyStart | |
| umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury); | |
| return gSystemDefaultCenturyStart; | |
| } | |
| int32_t HebrewCalendar::defaultCenturyStartYear() const { | |
| // lazy-evaluate systemDefaultCenturyStartYear | |
| umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury); | |
| return gSystemDefaultCenturyStartYear; | |
| } | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HebrewCalendar) | |
| U_NAMESPACE_END | |
| #endif // UCONFIG_NO_FORMATTING | |