1 /* 2 ****************************************************************************** 3 * Copyright (C) 2007-2013, International Business Machines Corporation 4 * and others. All Rights Reserved. 5 ****************************************************************************** 6 * 7 * File CHNSECAL.CPP 8 * 9 * Modification History: 10 * 11 * Date Name Description 12 * 9/18/2007 ajmacher ported from java ChineseCalendar 13 ***************************************************************************** 14 */ 15 16 #include "chnsecal.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 "unicode/simpletz.h" 25 #include "uhash.h" 26 #include "ucln_in.h" 27 28 // Debugging 29 #ifdef U_DEBUG_CHNSECAL 30 # include <stdio.h> 31 # include <stdarg.h> 32 static void debug_chnsecal_loc(const char *f, int32_t l) 33 { 34 fprintf(stderr, "%s:%d: ", f, l); 35 } 36 37 static void debug_chnsecal_msg(const char *pat, ...) 38 { 39 va_list ap; 40 va_start(ap, pat); 41 vfprintf(stderr, pat, ap); 42 fflush(stderr); 43 } 44 // must use double parens, i.e.: U_DEBUG_CHNSECAL_MSG(("four is: %d",4)); 45 #define U_DEBUG_CHNSECAL_MSG(x) {debug_chnsecal_loc(__FILE__,__LINE__);debug_chnsecal_msg x;} 46 #else 47 #define U_DEBUG_CHNSECAL_MSG(x) 48 #endif 49 50 51 // --- The cache -- 52 static UMutex astroLock = U_MUTEX_INITIALIZER; // pod bay door lock 53 static icu::CalendarAstronomer *gChineseCalendarAstro = NULL; 54 static icu::CalendarCache *gChineseCalendarWinterSolsticeCache = NULL; 55 static icu::CalendarCache *gChineseCalendarNewYearCache = NULL; 56 static icu::TimeZone *gChineseCalendarZoneAstroCalc = NULL; 57 static UBool gChineseCalendarZoneAstroCalcInitialized = FALSE; 58 59 /** 60 * The start year of the Chinese calendar, the 61st year of the reign 61 * of Huang Di. Some sources use the first year of his reign, 62 * resulting in EXTENDED_YEAR values 60 years greater and ERA (cycle) 63 * values one greater. 64 */ 65 static const int32_t CHINESE_EPOCH_YEAR = -2636; // Gregorian year 66 67 /** 68 * The offset from GMT in milliseconds at which we perform astronomical 69 * computations. Some sources use a different historically accurate 70 * offset of GMT+7:45:40 for years before 1929; we do not do this. 71 */ 72 static const int32_t CHINA_OFFSET = 8 * kOneHour; 73 74 /** 75 * Value to be added or subtracted from the local days of a new moon to 76 * get close to the next or prior new moon, but not cross it. Must be 77 * >= 1 and < CalendarAstronomer.SYNODIC_MONTH. 78 */ 79 static const int32_t SYNODIC_GAP = 25; 80 81 82 U_CDECL_BEGIN 83 static UBool calendar_chinese_cleanup(void) { 84 if (gChineseCalendarAstro) { 85 delete gChineseCalendarAstro; 86 gChineseCalendarAstro = NULL; 87 } 88 if (gChineseCalendarWinterSolsticeCache) { 89 delete gChineseCalendarWinterSolsticeCache; 90 gChineseCalendarWinterSolsticeCache = NULL; 91 } 92 if (gChineseCalendarNewYearCache) { 93 delete gChineseCalendarNewYearCache; 94 gChineseCalendarNewYearCache = NULL; 95 } 96 if (gChineseCalendarZoneAstroCalc) { 97 delete gChineseCalendarZoneAstroCalc; 98 gChineseCalendarZoneAstroCalc = NULL; 99 } 100 gChineseCalendarZoneAstroCalcInitialized = FALSE; 101 return TRUE; 102 } 103 U_CDECL_END 104 105 U_NAMESPACE_BEGIN 106 107 108 // Implementation of the ChineseCalendar class 109 110 111 //------------------------------------------------------------------------- 112 // Constructors... 113 //------------------------------------------------------------------------- 114 115 116 Calendar* ChineseCalendar::clone() const { 117 return new ChineseCalendar(*this); 118 } 119 120 ChineseCalendar::ChineseCalendar(const Locale& aLocale, UErrorCode& success) 121 : Calendar(TimeZone::createDefault(), aLocale, success), 122 isLeapYear(FALSE), 123 fEpochYear(CHINESE_EPOCH_YEAR), 124 fZoneAstroCalc(getChineseCalZoneAstroCalc()) 125 { 126 setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. 127 } 128 129 ChineseCalendar::ChineseCalendar(const Locale& aLocale, int32_t epochYear, 130 const TimeZone* zoneAstroCalc, UErrorCode &success) 131 : Calendar(TimeZone::createDefault(), aLocale, success), 132 isLeapYear(FALSE), 133 fEpochYear(epochYear), 134 fZoneAstroCalc(zoneAstroCalc) 135 { 136 setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. 137 } 138 139 ChineseCalendar::ChineseCalendar(const ChineseCalendar& other) : Calendar(other) { 140 isLeapYear = other.isLeapYear; 141 fEpochYear = other.fEpochYear; 142 fZoneAstroCalc = other.fZoneAstroCalc; 143 } 144 145 ChineseCalendar::~ChineseCalendar() 146 { 147 } 148 149 const char *ChineseCalendar::getType() const { 150 return "chinese"; 151 } 152 153 const TimeZone* ChineseCalendar::getChineseCalZoneAstroCalc(void) const { 154 UBool initialized; 155 UMTX_CHECK(&astroLock, gChineseCalendarZoneAstroCalcInitialized, initialized); 156 if (!initialized) { 157 umtx_lock(&astroLock); 158 { 159 if (!gChineseCalendarZoneAstroCalcInitialized) { 160 gChineseCalendarZoneAstroCalc = new SimpleTimeZone(CHINA_OFFSET, UNICODE_STRING_SIMPLE("CHINA_ZONE") ); 161 gChineseCalendarZoneAstroCalcInitialized = TRUE; 162 ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); 163 } 164 } 165 umtx_unlock(&astroLock); 166 } 167 return gChineseCalendarZoneAstroCalc; 168 } 169 170 //------------------------------------------------------------------------- 171 // Minimum / Maximum access functions 172 //------------------------------------------------------------------------- 173 174 175 static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = { 176 // Minimum Greatest Least Maximum 177 // Minimum Maximum 178 { 1, 1, 83333, 83333}, // ERA 179 { 1, 1, 60, 60}, // YEAR 180 { 0, 0, 11, 11}, // MONTH 181 { 1, 1, 50, 55}, // WEEK_OF_YEAR 182 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // WEEK_OF_MONTH 183 { 1, 1, 29, 30}, // DAY_OF_MONTH 184 { 1, 1, 353, 385}, // DAY_OF_YEAR 185 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DAY_OF_WEEK 186 { -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH 187 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // AM_PM 188 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR 189 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR_OF_DAY 190 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MINUTE 191 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // SECOND 192 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECOND 193 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // ZONE_OFFSET 194 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DST_OFFSET 195 { -5000000, -5000000, 5000000, 5000000}, // YEAR_WOY 196 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DOW_LOCAL 197 { -5000000, -5000000, 5000000, 5000000}, // EXTENDED_YEAR 198 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // JULIAN_DAY 199 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECONDS_IN_DAY 200 { 0, 0, 1, 1}, // IS_LEAP_MONTH 201 }; 202 203 204 /** 205 * @draft ICU 2.4 206 */ 207 int32_t ChineseCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const { 208 return LIMITS[field][limitType]; 209 } 210 211 212 //---------------------------------------------------------------------- 213 // Calendar framework 214 //---------------------------------------------------------------------- 215 216 /** 217 * Implement abstract Calendar method to return the extended year 218 * defined by the current fields. This will use either the ERA and 219 * YEAR field as the cycle and year-of-cycle, or the EXTENDED_YEAR 220 * field as the continuous year count, depending on which is newer. 221 * @stable ICU 2.8 222 */ 223 int32_t ChineseCalendar::handleGetExtendedYear() { 224 int32_t year; 225 if (newestStamp(UCAL_ERA, UCAL_YEAR, kUnset) <= fStamp[UCAL_EXTENDED_YEAR]) { 226 year = internalGet(UCAL_EXTENDED_YEAR, 1); // Default to year 1 227 } else { 228 int32_t cycle = internalGet(UCAL_ERA, 1) - 1; // 0-based cycle 229 // adjust to the instance specific epoch 230 year = cycle * 60 + internalGet(UCAL_YEAR, 1) - (fEpochYear - CHINESE_EPOCH_YEAR); 231 } 232 return year; 233 } 234 235 /** 236 * Override Calendar method to return the number of days in the given 237 * extended year and month. 238 * 239 * <p>Note: This method also reads the IS_LEAP_MONTH field to determine 240 * whether or not the given month is a leap month. 241 * @stable ICU 2.8 242 */ 243 int32_t ChineseCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const { 244 int32_t thisStart = handleComputeMonthStart(extendedYear, month, TRUE) - 245 kEpochStartAsJulianDay + 1; // Julian day -> local days 246 int32_t nextStart = newMoonNear(thisStart + SYNODIC_GAP, TRUE); 247 return nextStart - thisStart; 248 } 249 250 /** 251 * Override Calendar to compute several fields specific to the Chinese 252 * calendar system. These are: 253 * 254 * <ul><li>ERA 255 * <li>YEAR 256 * <li>MONTH 257 * <li>DAY_OF_MONTH 258 * <li>DAY_OF_YEAR 259 * <li>EXTENDED_YEAR</ul> 260 * 261 * The DAY_OF_WEEK and DOW_LOCAL fields are already set when this 262 * method is called. The getGregorianXxx() methods return Gregorian 263 * calendar equivalents for the given Julian day. 264 * 265 * <p>Compute the ChineseCalendar-specific field IS_LEAP_MONTH. 266 * @stable ICU 2.8 267 */ 268 void ChineseCalendar::handleComputeFields(int32_t julianDay, UErrorCode &/*status*/) { 269 270 computeChineseFields(julianDay - kEpochStartAsJulianDay, // local days 271 getGregorianYear(), getGregorianMonth(), 272 TRUE); // set all fields 273 } 274 275 /** 276 * Field resolution table that incorporates IS_LEAP_MONTH. 277 */ 278 const UFieldResolutionTable ChineseCalendar::CHINESE_DATE_PRECEDENCE[] = 279 { 280 { 281 { UCAL_DAY_OF_MONTH, kResolveSTOP }, 282 { UCAL_WEEK_OF_YEAR, UCAL_DAY_OF_WEEK, kResolveSTOP }, 283 { UCAL_WEEK_OF_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP }, 284 { UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP }, 285 { UCAL_WEEK_OF_YEAR, UCAL_DOW_LOCAL, kResolveSTOP }, 286 { UCAL_WEEK_OF_MONTH, UCAL_DOW_LOCAL, kResolveSTOP }, 287 { UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP }, 288 { UCAL_DAY_OF_YEAR, kResolveSTOP }, 289 { kResolveRemap | UCAL_DAY_OF_MONTH, UCAL_IS_LEAP_MONTH, kResolveSTOP }, 290 { kResolveSTOP } 291 }, 292 { 293 { UCAL_WEEK_OF_YEAR, kResolveSTOP }, 294 { UCAL_WEEK_OF_MONTH, kResolveSTOP }, 295 { UCAL_DAY_OF_WEEK_IN_MONTH, kResolveSTOP }, 296 { kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DAY_OF_WEEK, kResolveSTOP }, 297 { kResolveRemap | UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_DOW_LOCAL, kResolveSTOP }, 298 { kResolveSTOP } 299 }, 300 {{kResolveSTOP}} 301 }; 302 303 /** 304 * Override Calendar to add IS_LEAP_MONTH to the field resolution 305 * table. 306 * @stable ICU 2.8 307 */ 308 const UFieldResolutionTable* ChineseCalendar::getFieldResolutionTable() const { 309 return CHINESE_DATE_PRECEDENCE; 310 } 311 312 /** 313 * Return the Julian day number of day before the first day of the 314 * given month in the given extended year. 315 * 316 * <p>Note: This method reads the IS_LEAP_MONTH field to determine 317 * whether the given month is a leap month. 318 * @param eyear the extended year 319 * @param month the zero-based month. The month is also determined 320 * by reading the IS_LEAP_MONTH field. 321 * @return the Julian day number of the day before the first 322 * day of the given month and year 323 * @stable ICU 2.8 324 */ 325 int32_t ChineseCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool useMonth) const { 326 327 ChineseCalendar *nonConstThis = (ChineseCalendar*)this; // cast away const 328 329 // If the month is out of range, adjust it into range, and 330 // modify the extended year value accordingly. 331 if (month < 0 || month > 11) { 332 double m = month; 333 eyear += (int32_t)ClockMath::floorDivide(m, 12.0, m); 334 month = (int32_t)m; 335 } 336 337 int32_t gyear = eyear + fEpochYear - 1; // Gregorian year 338 int32_t theNewYear = newYear(gyear); 339 int32_t newMoon = newMoonNear(theNewYear + month * 29, TRUE); 340 341 int32_t julianDay = newMoon + kEpochStartAsJulianDay; 342 343 // Save fields for later restoration 344 int32_t saveMonth = internalGet(UCAL_MONTH); 345 int32_t saveIsLeapMonth = internalGet(UCAL_IS_LEAP_MONTH); 346 347 // Ignore IS_LEAP_MONTH field if useMonth is false 348 int32_t isLeapMonth = useMonth ? saveIsLeapMonth : 0; 349 350 UErrorCode status = U_ZERO_ERROR; 351 nonConstThis->computeGregorianFields(julianDay, status); 352 if (U_FAILURE(status)) 353 return 0; 354 355 // This will modify the MONTH and IS_LEAP_MONTH fields (only) 356 nonConstThis->computeChineseFields(newMoon, getGregorianYear(), 357 getGregorianMonth(), FALSE); 358 359 if (month != internalGet(UCAL_MONTH) || 360 isLeapMonth != internalGet(UCAL_IS_LEAP_MONTH)) { 361 newMoon = newMoonNear(newMoon + SYNODIC_GAP, TRUE); 362 julianDay = newMoon + kEpochStartAsJulianDay; 363 } 364 365 nonConstThis->internalSet(UCAL_MONTH, saveMonth); 366 nonConstThis->internalSet(UCAL_IS_LEAP_MONTH, saveIsLeapMonth); 367 368 return julianDay - 1; 369 } 370 371 372 /** 373 * Override Calendar to handle leap months properly. 374 * @stable ICU 2.8 375 */ 376 void ChineseCalendar::add(UCalendarDateFields field, int32_t amount, UErrorCode& status) { 377 switch (field) { 378 case UCAL_MONTH: 379 if (amount != 0) { 380 int32_t dom = get(UCAL_DAY_OF_MONTH, status); 381 if (U_FAILURE(status)) break; 382 int32_t day = get(UCAL_JULIAN_DAY, status) - kEpochStartAsJulianDay; // Get local day 383 if (U_FAILURE(status)) break; 384 int32_t moon = day - dom + 1; // New moon 385 offsetMonth(moon, dom, amount); 386 } 387 break; 388 default: 389 Calendar::add(field, amount, status); 390 break; 391 } 392 } 393 394 /** 395 * Override Calendar to handle leap months properly. 396 * @stable ICU 2.8 397 */ 398 void ChineseCalendar::add(EDateFields field, int32_t amount, UErrorCode& status) { 399 add((UCalendarDateFields)field, amount, status); 400 } 401 402 /** 403 * Override Calendar to handle leap months properly. 404 * @stable ICU 2.8 405 */ 406 void ChineseCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status) { 407 switch (field) { 408 case UCAL_MONTH: 409 if (amount != 0) { 410 int32_t dom = get(UCAL_DAY_OF_MONTH, status); 411 if (U_FAILURE(status)) break; 412 int32_t day = get(UCAL_JULIAN_DAY, status) - kEpochStartAsJulianDay; // Get local day 413 if (U_FAILURE(status)) break; 414 int32_t moon = day - dom + 1; // New moon (start of this month) 415 416 // Note throughout the following: Months 12 and 1 are never 417 // followed by a leap month (D&R p. 185). 418 419 // Compute the adjusted month number m. This is zero-based 420 // value from 0..11 in a non-leap year, and from 0..12 in a 421 // leap year. 422 int32_t m = get(UCAL_MONTH, status); // 0-based month 423 if (U_FAILURE(status)) break; 424 if (isLeapYear) { // (member variable) 425 if (get(UCAL_IS_LEAP_MONTH, status) == 1) { 426 ++m; 427 } else { 428 // Check for a prior leap month. (In the 429 // following, month 0 is the first month of the 430 // year.) Month 0 is never followed by a leap 431 // month, and we know month m is not a leap month. 432 // moon1 will be the start of month 0 if there is 433 // no leap month between month 0 and month m; 434 // otherwise it will be the start of month 1. 435 int moon1 = moon - 436 (int) (CalendarAstronomer::SYNODIC_MONTH * (m - 0.5)); 437 moon1 = newMoonNear(moon1, TRUE); 438 if (isLeapMonthBetween(moon1, moon)) { 439 ++m; 440 } 441 } 442 if (U_FAILURE(status)) break; 443 } 444 445 // Now do the standard roll computation on m, with the 446 // allowed range of 0..n-1, where n is 12 or 13. 447 int32_t n = isLeapYear ? 13 : 12; // Months in this year 448 int32_t newM = (m + amount) % n; 449 if (newM < 0) { 450 newM += n; 451 } 452 453 if (newM != m) { 454 offsetMonth(moon, dom, newM - m); 455 } 456 } 457 break; 458 default: 459 Calendar::roll(field, amount, status); 460 break; 461 } 462 } 463 464 void ChineseCalendar::roll(EDateFields field, int32_t amount, UErrorCode& status) { 465 roll((UCalendarDateFields)field, amount, status); 466 } 467 468 469 //------------------------------------------------------------------ 470 // Support methods and constants 471 //------------------------------------------------------------------ 472 473 /** 474 * Convert local days to UTC epoch milliseconds. 475 * This is not an accurate conversion in that getTimezoneOffset 476 * takes the milliseconds in GMT (not local time). In theory, more 477 * accurate algorithm can be implemented but practically we do not need 478 * to go through that complication as long as the historical timezone 479 * changes did not happen around the 'tricky' new moon (new moon around 480 * midnight). 481 * 482 * @param days days after January 1, 1970 0:00 in the astronomical base zone 483 * @return milliseconds after January 1, 1970 0:00 GMT 484 */ 485 double ChineseCalendar::daysToMillis(double days) const { 486 double millis = days * (double)kOneDay; 487 if (fZoneAstroCalc != NULL) { 488 int32_t rawOffset, dstOffset; 489 UErrorCode status = U_ZERO_ERROR; 490 fZoneAstroCalc->getOffset(millis, FALSE, rawOffset, dstOffset, status); 491 if (U_SUCCESS(status)) { 492 return millis - (double)(rawOffset + dstOffset); 493 } 494 } 495 return millis - (double)CHINA_OFFSET; 496 } 497 498 /** 499 * Convert UTC epoch milliseconds to local days. 500 * @param millis milliseconds after January 1, 1970 0:00 GMT 501 * @return days after January 1, 1970 0:00 in the astronomical base zone 502 */ 503 double ChineseCalendar::millisToDays(double millis) const { 504 if (fZoneAstroCalc != NULL) { 505 int32_t rawOffset, dstOffset; 506 UErrorCode status = U_ZERO_ERROR; 507 fZoneAstroCalc->getOffset(millis, FALSE, rawOffset, dstOffset, status); 508 if (U_SUCCESS(status)) { 509 return ClockMath::floorDivide(millis + (double)(rawOffset + dstOffset), kOneDay); 510 } 511 } 512 return ClockMath::floorDivide(millis + (double)CHINA_OFFSET, kOneDay); 513 } 514 515 //------------------------------------------------------------------ 516 // Astronomical computations 517 //------------------------------------------------------------------ 518 519 520 /** 521 * Return the major solar term on or after December 15 of the given 522 * Gregorian year, that is, the winter solstice of the given year. 523 * Computations are relative to Asia/Shanghai time zone. 524 * @param gyear a Gregorian year 525 * @return days after January 1, 1970 0:00 Asia/Shanghai of the 526 * winter solstice of the given year 527 */ 528 int32_t ChineseCalendar::winterSolstice(int32_t gyear) const { 529 530 UErrorCode status = U_ZERO_ERROR; 531 int32_t cacheValue = CalendarCache::get(&gChineseCalendarWinterSolsticeCache, gyear, status); 532 533 if (cacheValue == 0) { 534 // In books December 15 is used, but it fails for some years 535 // using our algorithms, e.g.: 1298 1391 1492 1553 1560. That 536 // is, winterSolstice(1298) starts search at Dec 14 08:00:00 537 // PST 1298 with a final result of Dec 14 10:31:59 PST 1299. 538 double ms = daysToMillis(Grego::fieldsToDay(gyear, UCAL_DECEMBER, 1)); 539 540 umtx_lock(&astroLock); 541 if(gChineseCalendarAstro == NULL) { 542 gChineseCalendarAstro = new CalendarAstronomer(); 543 ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); 544 } 545 gChineseCalendarAstro->setTime(ms); 546 UDate solarLong = gChineseCalendarAstro->getSunTime(CalendarAstronomer::WINTER_SOLSTICE(), TRUE); 547 umtx_unlock(&astroLock); 548 549 // Winter solstice is 270 degrees solar longitude aka Dongzhi 550 cacheValue = (int32_t)millisToDays(solarLong); 551 CalendarCache::put(&gChineseCalendarWinterSolsticeCache, gyear, cacheValue, status); 552 } 553 if(U_FAILURE(status)) { 554 cacheValue = 0; 555 } 556 return cacheValue; 557 } 558 559 /** 560 * Return the closest new moon to the given date, searching either 561 * forward or backward in time. 562 * @param days days after January 1, 1970 0:00 Asia/Shanghai 563 * @param after if true, search for a new moon on or after the given 564 * date; otherwise, search for a new moon before it 565 * @return days after January 1, 1970 0:00 Asia/Shanghai of the nearest 566 * new moon after or before <code>days</code> 567 */ 568 int32_t ChineseCalendar::newMoonNear(double days, UBool after) const { 569 570 umtx_lock(&astroLock); 571 if(gChineseCalendarAstro == NULL) { 572 gChineseCalendarAstro = new CalendarAstronomer(); 573 ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); 574 } 575 gChineseCalendarAstro->setTime(daysToMillis(days)); 576 UDate newMoon = gChineseCalendarAstro->getMoonTime(CalendarAstronomer::NEW_MOON(), after); 577 umtx_unlock(&astroLock); 578 579 return (int32_t) millisToDays(newMoon); 580 } 581 582 /** 583 * Return the nearest integer number of synodic months between 584 * two dates. 585 * @param day1 days after January 1, 1970 0:00 Asia/Shanghai 586 * @param day2 days after January 1, 1970 0:00 Asia/Shanghai 587 * @return the nearest integer number of months between day1 and day2 588 */ 589 int32_t ChineseCalendar::synodicMonthsBetween(int32_t day1, int32_t day2) const { 590 double roundme = ((day2 - day1) / CalendarAstronomer::SYNODIC_MONTH); 591 return (int32_t) (roundme + (roundme >= 0 ? .5 : -.5)); 592 } 593 594 /** 595 * Return the major solar term on or before a given date. This 596 * will be an integer from 1..12, with 1 corresponding to 330 degrees, 597 * 2 to 0 degrees, 3 to 30 degrees,..., and 12 to 300 degrees. 598 * @param days days after January 1, 1970 0:00 Asia/Shanghai 599 */ 600 int32_t ChineseCalendar::majorSolarTerm(int32_t days) const { 601 602 umtx_lock(&astroLock); 603 if(gChineseCalendarAstro == NULL) { 604 gChineseCalendarAstro = new CalendarAstronomer(); 605 ucln_i18n_registerCleanup(UCLN_I18N_CHINESE_CALENDAR, calendar_chinese_cleanup); 606 } 607 gChineseCalendarAstro->setTime(daysToMillis(days)); 608 UDate solarLongitude = gChineseCalendarAstro->getSunLongitude(); 609 umtx_unlock(&astroLock); 610 611 // Compute (floor(solarLongitude / (pi/6)) + 2) % 12 612 int32_t term = ( ((int32_t)(6 * solarLongitude / CalendarAstronomer::PI)) + 2 ) % 12; 613 if (term < 1) { 614 term += 12; 615 } 616 return term; 617 } 618 619 /** 620 * Return true if the given month lacks a major solar term. 621 * @param newMoon days after January 1, 1970 0:00 Asia/Shanghai of a new 622 * moon 623 */ 624 UBool ChineseCalendar::hasNoMajorSolarTerm(int32_t newMoon) const { 625 return majorSolarTerm(newMoon) == 626 majorSolarTerm(newMoonNear(newMoon + SYNODIC_GAP, TRUE)); 627 } 628 629 630 //------------------------------------------------------------------ 631 // Time to fields 632 //------------------------------------------------------------------ 633 634 /** 635 * Return true if there is a leap month on or after month newMoon1 and 636 * at or before month newMoon2. 637 * @param newMoon1 days after January 1, 1970 0:00 astronomical base zone 638 * of a new moon 639 * @param newMoon2 days after January 1, 1970 0:00 astronomical base zone 640 * of a new moon 641 */ 642 UBool ChineseCalendar::isLeapMonthBetween(int32_t newMoon1, int32_t newMoon2) const { 643 644 #ifdef U_DEBUG_CHNSECAL 645 // This is only needed to debug the timeOfAngle divergence bug. 646 // Remove this later. Liu 11/9/00 647 if (synodicMonthsBetween(newMoon1, newMoon2) >= 50) { 648 U_DEBUG_CHNSECAL_MSG(( 649 "isLeapMonthBetween(%d, %d): Invalid parameters", newMoon1, newMoon2 650 )); 651 } 652 #endif 653 654 return (newMoon2 >= newMoon1) && 655 (isLeapMonthBetween(newMoon1, newMoonNear(newMoon2 - SYNODIC_GAP, FALSE)) || 656 hasNoMajorSolarTerm(newMoon2)); 657 } 658 659 /** 660 * Compute fields for the Chinese calendar system. This method can 661 * either set all relevant fields, as required by 662 * <code>handleComputeFields()</code>, or it can just set the MONTH and 663 * IS_LEAP_MONTH fields, as required by 664 * <code>handleComputeMonthStart()</code>. 665 * 666 * <p>As a side effect, this method sets {@link #isLeapYear}. 667 * @param days days after January 1, 1970 0:00 astronomical base zone 668 * of the date to compute fields for 669 * @param gyear the Gregorian year of the given date 670 * @param gmonth the Gregorian month of the given date 671 * @param setAllFields if true, set the EXTENDED_YEAR, ERA, YEAR, 672 * DAY_OF_MONTH, and DAY_OF_YEAR fields. In either case set the MONTH 673 * and IS_LEAP_MONTH fields. 674 */ 675 void ChineseCalendar::computeChineseFields(int32_t days, int32_t gyear, int32_t gmonth, 676 UBool setAllFields) { 677 678 // Find the winter solstices before and after the target date. 679 // These define the boundaries of this Chinese year, specifically, 680 // the position of month 11, which always contains the solstice. 681 // We want solsticeBefore <= date < solsticeAfter. 682 int32_t solsticeBefore; 683 int32_t solsticeAfter = winterSolstice(gyear); 684 if (days < solsticeAfter) { 685 solsticeBefore = winterSolstice(gyear - 1); 686 } else { 687 solsticeBefore = solsticeAfter; 688 solsticeAfter = winterSolstice(gyear + 1); 689 } 690 691 // Find the start of the month after month 11. This will be either 692 // the prior month 12 or leap month 11 (very rare). Also find the 693 // start of the following month 11. 694 int32_t firstMoon = newMoonNear(solsticeBefore + 1, TRUE); 695 int32_t lastMoon = newMoonNear(solsticeAfter + 1, FALSE); 696 int32_t thisMoon = newMoonNear(days + 1, FALSE); // Start of this month 697 // Note: isLeapYear is a member variable 698 isLeapYear = synodicMonthsBetween(firstMoon, lastMoon) == 12; 699 700 int32_t month = synodicMonthsBetween(firstMoon, thisMoon); 701 if (isLeapYear && isLeapMonthBetween(firstMoon, thisMoon)) { 702 month--; 703 } 704 if (month < 1) { 705 month += 12; 706 } 707 708 UBool isLeapMonth = isLeapYear && 709 hasNoMajorSolarTerm(thisMoon) && 710 !isLeapMonthBetween(firstMoon, newMoonNear(thisMoon - SYNODIC_GAP, FALSE)); 711 712 internalSet(UCAL_MONTH, month-1); // Convert from 1-based to 0-based 713 internalSet(UCAL_IS_LEAP_MONTH, isLeapMonth?1:0); 714 715 if (setAllFields) { 716 717 // Extended year and cycle year is based on the epoch year 718 719 int32_t extended_year = gyear - fEpochYear; 720 int cycle_year = gyear - CHINESE_EPOCH_YEAR; 721 if (month < 11 || 722 gmonth >= UCAL_JULY) { 723 extended_year++; 724 cycle_year++; 725 } 726 int32_t dayOfMonth = days - thisMoon + 1; 727 728 internalSet(UCAL_EXTENDED_YEAR, extended_year); 729 730 // 0->0,60 1->1,1 60->1,60 61->2,1 etc. 731 int32_t yearOfCycle; 732 int32_t cycle = ClockMath::floorDivide(cycle_year - 1, 60, yearOfCycle); 733 internalSet(UCAL_ERA, cycle + 1); 734 internalSet(UCAL_YEAR, yearOfCycle + 1); 735 736 internalSet(UCAL_DAY_OF_MONTH, dayOfMonth); 737 738 // Days will be before the first new year we compute if this 739 // date is in month 11, leap 11, 12. There is never a leap 12. 740 // New year computations are cached so this should be cheap in 741 // the long run. 742 int32_t theNewYear = newYear(gyear); 743 if (days < theNewYear) { 744 theNewYear = newYear(gyear-1); 745 } 746 internalSet(UCAL_DAY_OF_YEAR, days - theNewYear + 1); 747 } 748 } 749 750 751 //------------------------------------------------------------------ 752 // Fields to time 753 //------------------------------------------------------------------ 754 755 /** 756 * Return the Chinese new year of the given Gregorian year. 757 * @param gyear a Gregorian year 758 * @return days after January 1, 1970 0:00 astronomical base zone of the 759 * Chinese new year of the given year (this will be a new moon) 760 */ 761 int32_t ChineseCalendar::newYear(int32_t gyear) const { 762 UErrorCode status = U_ZERO_ERROR; 763 int32_t cacheValue = CalendarCache::get(&gChineseCalendarNewYearCache, gyear, status); 764 765 if (cacheValue == 0) { 766 767 int32_t solsticeBefore= winterSolstice(gyear - 1); 768 int32_t solsticeAfter = winterSolstice(gyear); 769 int32_t newMoon1 = newMoonNear(solsticeBefore + 1, TRUE); 770 int32_t newMoon2 = newMoonNear(newMoon1 + SYNODIC_GAP, TRUE); 771 int32_t newMoon11 = newMoonNear(solsticeAfter + 1, FALSE); 772 773 if (synodicMonthsBetween(newMoon1, newMoon11) == 12 && 774 (hasNoMajorSolarTerm(newMoon1) || hasNoMajorSolarTerm(newMoon2))) { 775 cacheValue = newMoonNear(newMoon2 + SYNODIC_GAP, TRUE); 776 } else { 777 cacheValue = newMoon2; 778 } 779 780 CalendarCache::put(&gChineseCalendarNewYearCache, gyear, cacheValue, status); 781 } 782 if(U_FAILURE(status)) { 783 cacheValue = 0; 784 } 785 return cacheValue; 786 } 787 788 /** 789 * Adjust this calendar to be delta months before or after a given 790 * start position, pinning the day of month if necessary. The start 791 * position is given as a local days number for the start of the month 792 * and a day-of-month. Used by add() and roll(). 793 * @param newMoon the local days of the first day of the month of the 794 * start position (days after January 1, 1970 0:00 Asia/Shanghai) 795 * @param dom the 1-based day-of-month of the start position 796 * @param delta the number of months to move forward or backward from 797 * the start position 798 */ 799 void ChineseCalendar::offsetMonth(int32_t newMoon, int32_t dom, int32_t delta) { 800 UErrorCode status = U_ZERO_ERROR; 801 802 // Move to the middle of the month before our target month. 803 newMoon += (int32_t) (CalendarAstronomer::SYNODIC_MONTH * (delta - 0.5)); 804 805 // Search forward to the target month's new moon 806 newMoon = newMoonNear(newMoon, TRUE); 807 808 // Find the target dom 809 int32_t jd = newMoon + kEpochStartAsJulianDay - 1 + dom; 810 811 // Pin the dom. In this calendar all months are 29 or 30 days 812 // so pinning just means handling dom 30. 813 if (dom > 29) { 814 set(UCAL_JULIAN_DAY, jd-1); 815 // TODO Fix this. We really shouldn't ever have to 816 // explicitly call complete(). This is either a bug in 817 // this method, in ChineseCalendar, or in 818 // Calendar.getActualMaximum(). I suspect the last. 819 complete(status); 820 if (U_FAILURE(status)) return; 821 if (getActualMaximum(UCAL_DAY_OF_MONTH, status) >= dom) { 822 if (U_FAILURE(status)) return; 823 set(UCAL_JULIAN_DAY, jd); 824 } 825 } else { 826 set(UCAL_JULIAN_DAY, jd); 827 } 828 } 829 830 831 UBool 832 ChineseCalendar::inDaylightTime(UErrorCode& status) const 833 { 834 // copied from GregorianCalendar 835 if (U_FAILURE(status) || !getTimeZone().useDaylightTime()) 836 return FALSE; 837 838 // Force an update of the state of the Calendar. 839 ((ChineseCalendar*)this)->complete(status); // cast away const 840 841 return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE); 842 } 843 844 // default century 845 const UDate ChineseCalendar::fgSystemDefaultCentury = DBL_MIN; 846 const int32_t ChineseCalendar::fgSystemDefaultCenturyYear = -1; 847 848 UDate ChineseCalendar::fgSystemDefaultCenturyStart = DBL_MIN; 849 int32_t ChineseCalendar::fgSystemDefaultCenturyStartYear = -1; 850 851 852 UBool ChineseCalendar::haveDefaultCentury() const 853 { 854 return TRUE; 855 } 856 857 UDate ChineseCalendar::defaultCenturyStart() const 858 { 859 return internalGetDefaultCenturyStart(); 860 } 861 862 int32_t ChineseCalendar::defaultCenturyStartYear() const 863 { 864 return internalGetDefaultCenturyStartYear(); 865 } 866 867 UDate 868 ChineseCalendar::internalGetDefaultCenturyStart() const 869 { 870 // lazy-evaluate systemDefaultCenturyStart 871 UBool needsUpdate; 872 UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate); 873 874 if (needsUpdate) { 875 initializeSystemDefaultCentury(); 876 } 877 878 // use defaultCenturyStart unless it's the flag value; 879 // then use systemDefaultCenturyStart 880 881 return fgSystemDefaultCenturyStart; 882 } 883 884 int32_t 885 ChineseCalendar::internalGetDefaultCenturyStartYear() const 886 { 887 // lazy-evaluate systemDefaultCenturyStartYear 888 UBool needsUpdate; 889 UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate); 890 891 if (needsUpdate) { 892 initializeSystemDefaultCentury(); 893 } 894 895 // use defaultCenturyStart unless it's the flag value; 896 // then use systemDefaultCenturyStartYear 897 898 return fgSystemDefaultCenturyStartYear; 899 } 900 901 void 902 ChineseCalendar::initializeSystemDefaultCentury() 903 { 904 // initialize systemDefaultCentury and systemDefaultCenturyYear based 905 // on the current time. They'll be set to 80 years before 906 // the current time. 907 UErrorCode status = U_ZERO_ERROR; 908 ChineseCalendar calendar(Locale("@calendar=chinese"),status); 909 if (U_SUCCESS(status)) 910 { 911 calendar.setTime(Calendar::getNow(), status); 912 calendar.add(UCAL_YEAR, -80, status); 913 UDate newStart = calendar.getTime(status); 914 int32_t newYear = calendar.get(UCAL_YEAR, status); 915 umtx_lock(NULL); 916 if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury) 917 { 918 fgSystemDefaultCenturyStartYear = newYear; 919 fgSystemDefaultCenturyStart = newStart; 920 } 921 umtx_unlock(NULL); 922 } 923 // We have no recourse upon failure unless we want to propagate the failure 924 // out. 925 } 926 927 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ChineseCalendar) 928 929 U_NAMESPACE_END 930 931 #endif 932 933
