The Tor Browser / file comparison

comparison: intl/icu/source/i18n/chnsecal.cpp

intl/icu/source/i18n/chnsecal.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial