1 /*
2 *******************************************************************************
3 * Copyright (C) 1997-2007, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 *
7 * File GREGOCAL.CPP
8 *
9 * Modification History:
10 *
11 * Date Name Description
12 * 02/05/97 clhuang Creation.
13 * 03/28/97 aliu Made highly questionable fix to computeFields to
14 * handle DST correctly.
15 * 04/22/97 aliu Cleaned up code drastically. Added monthLength().
16 * Finished unimplemented parts of computeTime() for
17 * week-based date determination. Removed quetionable
18 * fix and wrote correct fix for computeFields() and
19 * daylight time handling. Rewrote inDaylightTime()
20 * and computeFields() to handle sensitive Daylight to
21 * Standard time transitions correctly.
22 * 05/08/97 aliu Added code review changes. Fixed isLeapYear() to
23 * not cutover.
24 * 08/12/97 aliu Added equivalentTo. Misc other fixes. Updated
25 * add() from Java source.
26 * 07/28/98 stephen Sync up with JDK 1.2
27 * 09/14/98 stephen Changed type of kOneDay, kOneWeek to double.
28 * Fixed bug in roll()
29 * 10/15/99 aliu Fixed j31, incorrect WEEK_OF_YEAR computation.
30 * 10/15/99 aliu Fixed j32, cannot set date to Feb 29 2000 AD.
31 * {JDK bug 4210209 4209272}
32 * 11/15/99 weiv Added YEAR_WOY and DOW_LOCAL computation
33 * to timeToFields method, updated kMinValues, kMaxValues & kLeastMaxValues
34 * 12/09/99 aliu Fixed j81, calculation errors and roll bugs
35 * in year of cutover.
36 * 01/24/2000 aliu Revised computeJulianDay for YEAR YEAR_WOY WOY.
37 ********************************************************************************
38 */
39
40 #include "unicode/utypes.h"
41 #include <float.h>
42
43 #if !UCONFIG_NO_FORMATTING
44
45 #include "unicode/gregocal.h"
46 #include "gregoimp.h"
47 #include "umutex.h"
48 #include "uassert.h"
49
50 // *****************************************************************************
51 // class GregorianCalendar
52 // *****************************************************************************
53
54 /**
55 * Note that the Julian date used here is not a true Julian date, since
56 * it is measured from midnight, not noon. This value is the Julian
57 * day number of January 1, 1970 (Gregorian calendar) at noon UTC. [LIU]
58 */
59
60 static const int32_t kNumDays[]
61 = {0,31,59,90,120,151,181,212,243,273,304,334}; // 0-based, for day-in-year
62 static const int32_t kLeapNumDays[]
63 = {0,31,60,91,121,152,182,213,244,274,305,335}; // 0-based, for day-in-year
64 static const int32_t kMonthLength[]
65 = {31,28,31,30,31,30,31,31,30,31,30,31}; // 0-based
66 static const int32_t kLeapMonthLength[]
67 = {31,29,31,30,31,30,31,31,30,31,30,31}; // 0-based
68
69 // setTimeInMillis() limits the Julian day range to +/-7F000000.
70 // This would seem to limit the year range to:
71 // ms=+183882168921600000 jd=7f000000 December 20, 5828963 AD
72 // ms=-184303902528000000 jd=81000000 September 20, 5838270 BC
73 // HOWEVER, CalendarRegressionTest/Test4167060 shows that the actual
74 // range limit on the year field is smaller (~ +/-140000). [alan 3.0]
75
76 static const int32_t kGregorianCalendarLimits[UCAL_FIELD_COUNT][4] = {
77 // Minimum Greatest Least Maximum
78 // Minimum Maximum
79 { 0, 0, 1, 1 }, // ERA
80 { 1, 1, 140742, 144683 }, // YEAR
81 { 0, 0, 11, 11 }, // MONTH
82 { 1, 1, 52, 53 }, // WEEK_OF_YEAR
83 { 0, 0, 4, 6 }, // WEEK_OF_MONTH
84 { 1, 1, 28, 31 }, // DAY_OF_MONTH
85 { 1, 1, 365, 366 }, // DAY_OF_YEAR
86 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// DAY_OF_WEEK
87 { -1, -1, 4, 5 }, // DAY_OF_WEEK_IN_MONTH
88 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// AM_PM
89 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// HOUR
90 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// HOUR_OF_DAY
91 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// MINUTE
92 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// SECOND
93 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// MILLISECOND
94 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// ZONE_OFFSET
95 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// DST_OFFSET
96 { -140742, -140742, 140742, 144683 }, // YEAR_WOY
97 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// DOW_LOCAL
98 { -140742, -140742, 140742, 144683 }, // EXTENDED_YEAR
99 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1},// JULIAN_DAY
100 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1} // MILLISECONDS_IN_DAY
101 };
102
103 /*
104 * <pre>
105 * Greatest Least
106 * Field name Minimum Minimum Maximum Maximum
107 * ---------- ------- ------- ------- -------
108 * ERA 0 0 1 1
109 * YEAR 1 1 140742 144683
110 * MONTH 0 0 11 11
111 * WEEK_OF_YEAR 1 1 52 53
112 * WEEK_OF_MONTH 0 0 4 6
113 * DAY_OF_MONTH 1 1 28 31
114 * DAY_OF_YEAR 1 1 365 366
115 * DAY_OF_WEEK 1 1 7 7
116 * DAY_OF_WEEK_IN_MONTH -1 -1 4 5
117 * AM_PM 0 0 1 1
118 * HOUR 0 0 11 11
119 * HOUR_OF_DAY 0 0 23 23
120 * MINUTE 0 0 59 59
121 * SECOND 0 0 59 59
122 * MILLISECOND 0 0 999 999
123 * ZONE_OFFSET -12* -12* 12* 12*
124 * DST_OFFSET 0 0 1* 1*
125 * YEAR_WOY 1 1 140742 144683
126 * DOW_LOCAL 1 1 7 7
127 * </pre>
128 * (*) In units of one-hour
129 */
130
131 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
132 #include <stdio.h>
133 #endif
134
135 U_NAMESPACE_BEGIN
136
137 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(GregorianCalendar)
138
139 // 00:00:00 UTC, October 15, 1582, expressed in ms from the epoch.
140 // Note that only Italy and other Catholic countries actually
141 // observed this cutover. Most other countries followed in
142 // the next few centuries, some as late as 1928. [LIU]
143 // in Java, -12219292800000L
144 //const UDate GregorianCalendar::kPapalCutover = -12219292800000L;
145 static const uint32_t kCutoverJulianDay = 2299161;
146 static const UDate kPapalCutover = (2299161.0 - kEpochStartAsJulianDay) * U_MILLIS_PER_DAY;
147 //static const UDate kPapalCutoverJulian = (2299161.0 - kEpochStartAsJulianDay);
148
149 // -------------------------------------
150
GregorianCalendar(UErrorCode & status)151 GregorianCalendar::GregorianCalendar(UErrorCode& status)
152 : Calendar(TimeZone::createDefault(), Locale::getDefault(), status),
153 fGregorianCutover(kPapalCutover),
154 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
155 fIsGregorian(TRUE), fInvertGregorian(FALSE)
156 {
157 setTimeInMillis(getNow(), status);
158 }
159
160 // -------------------------------------
161
GregorianCalendar(TimeZone * zone,UErrorCode & status)162 GregorianCalendar::GregorianCalendar(TimeZone* zone, UErrorCode& status)
163 : Calendar(zone, Locale::getDefault(), status),
164 fGregorianCutover(kPapalCutover),
165 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
166 fIsGregorian(TRUE), fInvertGregorian(FALSE)
167 {
168 setTimeInMillis(getNow(), status);
169 }
170
171 // -------------------------------------
172
GregorianCalendar(const TimeZone & zone,UErrorCode & status)173 GregorianCalendar::GregorianCalendar(const TimeZone& zone, UErrorCode& status)
174 : Calendar(zone, Locale::getDefault(), status),
175 fGregorianCutover(kPapalCutover),
176 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
177 fIsGregorian(TRUE), fInvertGregorian(FALSE)
178 {
179 setTimeInMillis(getNow(), status);
180 }
181
182 // -------------------------------------
183
GregorianCalendar(const Locale & aLocale,UErrorCode & status)184 GregorianCalendar::GregorianCalendar(const Locale& aLocale, UErrorCode& status)
185 : Calendar(TimeZone::createDefault(), aLocale, status),
186 fGregorianCutover(kPapalCutover),
187 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
188 fIsGregorian(TRUE), fInvertGregorian(FALSE)
189 {
190 setTimeInMillis(getNow(), status);
191 }
192
193 // -------------------------------------
194
GregorianCalendar(TimeZone * zone,const Locale & aLocale,UErrorCode & status)195 GregorianCalendar::GregorianCalendar(TimeZone* zone, const Locale& aLocale,
196 UErrorCode& status)
197 : Calendar(zone, aLocale, status),
198 fGregorianCutover(kPapalCutover),
199 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
200 fIsGregorian(TRUE), fInvertGregorian(FALSE)
201 {
202 setTimeInMillis(getNow(), status);
203 }
204
205 // -------------------------------------
206
GregorianCalendar(const TimeZone & zone,const Locale & aLocale,UErrorCode & status)207 GregorianCalendar::GregorianCalendar(const TimeZone& zone, const Locale& aLocale,
208 UErrorCode& status)
209 : Calendar(zone, aLocale, status),
210 fGregorianCutover(kPapalCutover),
211 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
212 fIsGregorian(TRUE), fInvertGregorian(FALSE)
213 {
214 setTimeInMillis(getNow(), status);
215 }
216
217 // -------------------------------------
218
GregorianCalendar(int32_t year,int32_t month,int32_t date,UErrorCode & status)219 GregorianCalendar::GregorianCalendar(int32_t year, int32_t month, int32_t date,
220 UErrorCode& status)
221 : Calendar(TimeZone::createDefault(), Locale::getDefault(), status),
222 fGregorianCutover(kPapalCutover),
223 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
224 fIsGregorian(TRUE), fInvertGregorian(FALSE)
225 {
226 set(UCAL_ERA, AD);
227 set(UCAL_YEAR, year);
228 set(UCAL_MONTH, month);
229 set(UCAL_DATE, date);
230 }
231
232 // -------------------------------------
233
GregorianCalendar(int32_t year,int32_t month,int32_t date,int32_t hour,int32_t minute,UErrorCode & status)234 GregorianCalendar::GregorianCalendar(int32_t year, int32_t month, int32_t date,
235 int32_t hour, int32_t minute, UErrorCode& status)
236 : Calendar(TimeZone::createDefault(), Locale::getDefault(), status),
237 fGregorianCutover(kPapalCutover),
238 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
239 fIsGregorian(TRUE), fInvertGregorian(FALSE)
240 {
241 set(UCAL_ERA, AD);
242 set(UCAL_YEAR, year);
243 set(UCAL_MONTH, month);
244 set(UCAL_DATE, date);
245 set(UCAL_HOUR_OF_DAY, hour);
246 set(UCAL_MINUTE, minute);
247 }
248
249 // -------------------------------------
250
GregorianCalendar(int32_t year,int32_t month,int32_t date,int32_t hour,int32_t minute,int32_t second,UErrorCode & status)251 GregorianCalendar::GregorianCalendar(int32_t year, int32_t month, int32_t date,
252 int32_t hour, int32_t minute, int32_t second,
253 UErrorCode& status)
254 : Calendar(TimeZone::createDefault(), Locale::getDefault(), status),
255 fGregorianCutover(kPapalCutover),
256 fCutoverJulianDay(kCutoverJulianDay), fNormalizedGregorianCutover(fGregorianCutover), fGregorianCutoverYear(1582),
257 fIsGregorian(TRUE), fInvertGregorian(FALSE)
258 {
259 set(UCAL_ERA, AD);
260 set(UCAL_YEAR, year);
261 set(UCAL_MONTH, month);
262 set(UCAL_DATE, date);
263 set(UCAL_HOUR_OF_DAY, hour);
264 set(UCAL_MINUTE, minute);
265 set(UCAL_SECOND, second);
266 }
267
268 // -------------------------------------
269
~GregorianCalendar()270 GregorianCalendar::~GregorianCalendar()
271 {
272 }
273
274 // -------------------------------------
275
GregorianCalendar(const GregorianCalendar & source)276 GregorianCalendar::GregorianCalendar(const GregorianCalendar &source)
277 : Calendar(source),
278 fGregorianCutover(source.fGregorianCutover),
279 fCutoverJulianDay(source.fCutoverJulianDay), fNormalizedGregorianCutover(source.fNormalizedGregorianCutover), fGregorianCutoverYear(source.fGregorianCutoverYear),
280 fIsGregorian(source.fIsGregorian), fInvertGregorian(source.fInvertGregorian)
281 {
282 }
283
284 // -------------------------------------
285
clone() const286 Calendar* GregorianCalendar::clone() const
287 {
288 return new GregorianCalendar(*this);
289 }
290
291 // -------------------------------------
292
293 GregorianCalendar &
operator =(const GregorianCalendar & right)294 GregorianCalendar::operator=(const GregorianCalendar &right)
295 {
296 if (this != &right)
297 {
298 Calendar::operator=(right);
299 fGregorianCutover = right.fGregorianCutover;
300 fNormalizedGregorianCutover = right.fNormalizedGregorianCutover;
301 fGregorianCutoverYear = right.fGregorianCutoverYear;
302 fCutoverJulianDay = right.fCutoverJulianDay;
303 }
304 return *this;
305 }
306
307 // -------------------------------------
308
isEquivalentTo(const Calendar & other) const309 UBool GregorianCalendar::isEquivalentTo(const Calendar& other) const
310 {
311 // Calendar override.
312 return Calendar::isEquivalentTo(other) &&
313 fGregorianCutover == ((GregorianCalendar*)&other)->fGregorianCutover;
314 }
315
316 // -------------------------------------
317
318 void
setGregorianChange(UDate date,UErrorCode & status)319 GregorianCalendar::setGregorianChange(UDate date, UErrorCode& status)
320 {
321 if (U_FAILURE(status))
322 return;
323
324 fGregorianCutover = date;
325
326 // Precompute two internal variables which we use to do the actual
327 // cutover computations. These are the normalized cutover, which is the
328 // midnight at or before the cutover, and the cutover year. The
329 // normalized cutover is in pure date milliseconds; it contains no time
330 // of day or timezone component, and it used to compare against other
331 // pure date values.
332 int32_t cutoverDay = (int32_t)Math::floorDivide(fGregorianCutover, (double)kOneDay);
333 fNormalizedGregorianCutover = cutoverDay * kOneDay;
334
335 // Handle the rare case of numeric overflow. If the user specifies a
336 // change of UDate(Long.MIN_VALUE), in order to get a pure Gregorian
337 // calendar, then the epoch day is -106751991168, which when multiplied
338 // by ONE_DAY gives 9223372036794351616 -- the negative value is too
339 // large for 64 bits, and overflows into a positive value. We correct
340 // this by using the next day, which for all intents is semantically
341 // equivalent.
342 if (cutoverDay < 0 && fNormalizedGregorianCutover > 0) {
343 fNormalizedGregorianCutover = (cutoverDay + 1) * kOneDay;
344 }
345
346 // Normalize the year so BC values are represented as 0 and negative
347 // values.
348 GregorianCalendar *cal = new GregorianCalendar(getTimeZone(), status);
349 /* test for NULL */
350 if (cal == 0) {
351 status = U_MEMORY_ALLOCATION_ERROR;
352 return;
353 }
354 if(U_FAILURE(status))
355 return;
356 cal->setTime(date, status);
357 fGregorianCutoverYear = cal->get(UCAL_YEAR, status);
358 if (cal->get(UCAL_ERA, status) == BC)
359 fGregorianCutoverYear = 1 - fGregorianCutoverYear;
360 fCutoverJulianDay = cutoverDay;
361 delete cal;
362 }
363
364
handleComputeFields(int32_t julianDay,UErrorCode & status)365 void GregorianCalendar::handleComputeFields(int32_t julianDay, UErrorCode& status) {
366 int32_t eyear, month, dayOfMonth, dayOfYear;
367
368
369 if(U_FAILURE(status)) {
370 return;
371 }
372
373 #if defined (U_DEBUG_CAL)
374 fprintf(stderr, "%s:%d: jd%d- (greg's %d)- [cut=%d]\n",
375 __FILE__, __LINE__, julianDay, getGregorianDayOfYear(), fCutoverJulianDay);
376 #endif
377
378
379 if (julianDay >= fCutoverJulianDay) {
380 month = getGregorianMonth();
381 dayOfMonth = getGregorianDayOfMonth();
382 dayOfYear = getGregorianDayOfYear();
383 eyear = getGregorianYear();
384 } else {
385 // The Julian epoch day (not the same as Julian Day)
386 // is zero on Saturday December 30, 0 (Gregorian).
387 int32_t julianEpochDay = julianDay - (kJan1_1JulianDay - 2);
388 eyear = (int32_t) Math::floorDivide(4*julianEpochDay + 1464, 1461);
389
390 // Compute the Julian calendar day number for January 1, eyear
391 int32_t january1 = 365*(eyear-1) + Math::floorDivide(eyear-1, (int32_t)4);
392 dayOfYear = (julianEpochDay - january1); // 0-based
393
394 // Julian leap years occurred historically every 4 years starting
395 // with 8 AD. Before 8 AD the spacing is irregular; every 3 years
396 // from 45 BC to 9 BC, and then none until 8 AD. However, we don't
397 // implement this historical detail; instead, we implement the
398 // computatinally cleaner proleptic calendar, which assumes
399 // consistent 4-year cycles throughout time.
400 UBool isLeap = ((eyear&0x3) == 0); // equiv. to (eyear%4 == 0)
401
402 // Common Julian/Gregorian calculation
403 int32_t correction = 0;
404 int32_t march1 = isLeap ? 60 : 59; // zero-based DOY for March 1
405 if (dayOfYear >= march1) {
406 correction = isLeap ? 1 : 2;
407 }
408 month = (12 * (dayOfYear + correction) + 6) / 367; // zero-based month
409 dayOfMonth = dayOfYear - (isLeap?kLeapNumDays[month]:kNumDays[month]) + 1; // one-based DOM
410 ++dayOfYear;
411 #if defined (U_DEBUG_CAL)
412 // fprintf(stderr, "%d - %d[%d] + 1\n", dayOfYear, isLeap?kLeapNumDays[month]:kNumDays[month], month );
413 // fprintf(stderr, "%s:%d: greg's HCF %d -> %d/%d/%d not %d/%d/%d\n",
414 // __FILE__, __LINE__,julianDay,
415 // eyear,month,dayOfMonth,
416 // getGregorianYear(), getGregorianMonth(), getGregorianDayOfMonth() );
417 fprintf(stderr, "%s:%d: doy %d (greg's %d)- [cut=%d]\n",
418 __FILE__, __LINE__, dayOfYear, getGregorianDayOfYear(), fCutoverJulianDay);
419 #endif
420
421 }
422
423 // [j81] if we are after the cutover in its year, shift the day of the year
424 if((eyear == fGregorianCutoverYear) && (julianDay >= fCutoverJulianDay)) {
425 //from handleComputeMonthStart
426 int32_t gregShift = Grego::gregorianShift(eyear);
427 #if defined (U_DEBUG_CAL)
428 fprintf(stderr, "%s:%d: gregorian shift %d ::: doy%d => %d [cut=%d]\n",
429 __FILE__, __LINE__,gregShift, dayOfYear, dayOfYear+gregShift, fCutoverJulianDay);
430 #endif
431 dayOfYear += gregShift;
432 }
433
434 internalSet(UCAL_MONTH, month);
435 internalSet(UCAL_DAY_OF_MONTH, dayOfMonth);
436 internalSet(UCAL_DAY_OF_YEAR, dayOfYear);
437 internalSet(UCAL_EXTENDED_YEAR, eyear);
438 int32_t era = AD;
439 if (eyear < 1) {
440 era = BC;
441 eyear = 1 - eyear;
442 }
443 internalSet(UCAL_ERA, era);
444 internalSet(UCAL_YEAR, eyear);
445 }
446
447
448 // -------------------------------------
449
450 UDate
getGregorianChange() const451 GregorianCalendar::getGregorianChange() const
452 {
453 return fGregorianCutover;
454 }
455
456 // -------------------------------------
457
458 UBool
isLeapYear(int32_t year) const459 GregorianCalendar::isLeapYear(int32_t year) const
460 {
461 // MSVC complains bitterly if we try to use Grego::isLeapYear here
462 // NOTE: year&0x3 == year%4
463 return (year >= fGregorianCutoverYear ?
464 (((year&0x3) == 0) && ((year%100 != 0) || (year%400 == 0))) : // Gregorian
465 ((year&0x3) == 0)); // Julian
466 }
467
468 // -------------------------------------
469
handleComputeJulianDay(UCalendarDateFields bestField)470 int32_t GregorianCalendar::handleComputeJulianDay(UCalendarDateFields bestField)
471 {
472 fInvertGregorian = FALSE;
473
474 int32_t jd = Calendar::handleComputeJulianDay(bestField);
475
476 if((bestField == UCAL_WEEK_OF_YEAR) && // if we are doing WOY calculations, we are counting relative to Jan 1 *julian*
477 (internalGet(UCAL_EXTENDED_YEAR)==fGregorianCutoverYear) &&
478 jd >= fCutoverJulianDay) {
479 fInvertGregorian = TRUE; // So that the Julian Jan 1 will be used in handleComputeMonthStart
480 return Calendar::handleComputeJulianDay(bestField);
481 }
482
483
484 // The following check handles portions of the cutover year BEFORE the
485 // cutover itself happens.
486 //if ((fIsGregorian==TRUE) != (jd >= fCutoverJulianDay)) { /* cutoverJulianDay)) { */
487 if ((fIsGregorian==TRUE) != (jd >= fCutoverJulianDay)) { /* cutoverJulianDay)) { */
488 #if defined (U_DEBUG_CAL)
489 fprintf(stderr, "%s:%d: jd [invert] %d\n",
490 __FILE__, __LINE__, jd);
491 #endif
492 fInvertGregorian = TRUE;
493 jd = Calendar::handleComputeJulianDay(bestField);
494 #if defined (U_DEBUG_CAL)
495 fprintf(stderr, "%s:%d: fIsGregorian %s, fInvertGregorian %s - ",
496 __FILE__, __LINE__,fIsGregorian?"T":"F", fInvertGregorian?"T":"F");
497 fprintf(stderr, " jd NOW %d\n",
498 jd);
499 #endif
500 } else {
501 #if defined (U_DEBUG_CAL)
502 fprintf(stderr, "%s:%d: jd [==] %d - %sfIsGregorian %sfInvertGregorian, %d\n",
503 __FILE__, __LINE__, jd, fIsGregorian?"T":"F", fInvertGregorian?"T":"F", bestField);
504 #endif
505 }
506
507 if(fIsGregorian && (internalGet(UCAL_EXTENDED_YEAR) == fGregorianCutoverYear)) {
508 int32_t gregShift = Grego::gregorianShift(internalGet(UCAL_EXTENDED_YEAR));
509 if (bestField == UCAL_DAY_OF_YEAR) {
510 #if defined (U_DEBUG_CAL)
511 fprintf(stderr, "%s:%d: [DOY%d] gregorian shift of JD %d += %d\n",
512 __FILE__, __LINE__, fFields[bestField],jd, gregShift);
513 #endif
514 jd -= gregShift;
515 } else if ( bestField == UCAL_WEEK_OF_MONTH ) {
516 int32_t weekShift = 14;
517 #if defined (U_DEBUG_CAL)
518 fprintf(stderr, "%s:%d: [WOY/WOM] gregorian week shift of %d += %d\n",
519 __FILE__, __LINE__, jd, weekShift);
520 #endif
521 jd += weekShift; // shift by weeks for week based fields.
522 }
523 }
524
525 return jd;
526 }
527
handleComputeMonthStart(int32_t eyear,int32_t month,UBool) const528 int32_t GregorianCalendar::handleComputeMonthStart(int32_t eyear, int32_t month,
529
530 UBool /* useMonth */) const
531 {
532 GregorianCalendar *nonConstThis = (GregorianCalendar*)this; // cast away const
533
534 // If the month is out of range, adjust it into range, and
535 // modify the extended year value accordingly.
536 if (month < 0 || month > 11) {
537 eyear += Math::floorDivide(month, 12, month);
538 }
539
540 UBool isLeap = eyear%4 == 0;
541 int32_t y = eyear-1;
542 int32_t julianDay = 365*y + Math::floorDivide(y, 4) + (kJan1_1JulianDay - 3);
543
544 nonConstThis->fIsGregorian = (eyear >= fGregorianCutoverYear);
545 #if defined (U_DEBUG_CAL)
546 fprintf(stderr, "%s:%d: (hcms%d/%d) fIsGregorian %s, fInvertGregorian %s\n",
547 __FILE__, __LINE__, eyear,month, fIsGregorian?"T":"F", fInvertGregorian?"T":"F");
548 #endif
549 if (fInvertGregorian) {
550 nonConstThis->fIsGregorian = !fIsGregorian;
551 }
552 if (fIsGregorian) {
553 isLeap = isLeap && ((eyear%100 != 0) || (eyear%400 == 0));
554 // Add 2 because Gregorian calendar starts 2 days after
555 // Julian calendar
556 int32_t gregShift = Grego::gregorianShift(eyear);
557 #if defined (U_DEBUG_CAL)
558 fprintf(stderr, "%s:%d: (hcms%d/%d) gregorian shift of %d += %d\n",
559 __FILE__, __LINE__, eyear, month, julianDay, gregShift);
560 #endif
561 julianDay += gregShift;
562 }
563
564 // At this point julianDay indicates the day BEFORE the first
565 // day of January 1, <eyear> of either the Julian or Gregorian
566 // calendar.
567
568 if (month != 0) {
569 julianDay += isLeap?kLeapNumDays[month]:kNumDays[month];
570 }
571
572 return julianDay;
573 }
574
handleGetMonthLength(int32_t extendedYear,int32_t month) const575 int32_t GregorianCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const
576 {
577 // If the month is out of range, adjust it into range, and
578 // modify the extended year value accordingly.
579 if (month < 0 || month > 11) {
580 extendedYear += Math::floorDivide(month, 12, month);
581 }
582
583 return isLeapYear(extendedYear) ? kLeapMonthLength[month] : kMonthLength[month];
584 }
585
handleGetYearLength(int32_t eyear) const586 int32_t GregorianCalendar::handleGetYearLength(int32_t eyear) const {
587 return isLeapYear(eyear) ? 366 : 365;
588 }
589
590
591 int32_t
monthLength(int32_t month) const592 GregorianCalendar::monthLength(int32_t month) const
593 {
594 int32_t year = internalGet(UCAL_EXTENDED_YEAR);
595 return handleGetMonthLength(year, month);
596 }
597
598 // -------------------------------------
599
600 int32_t
monthLength(int32_t month,int32_t year) const601 GregorianCalendar::monthLength(int32_t month, int32_t year) const
602 {
603 return isLeapYear(year) ? kLeapMonthLength[month] : kMonthLength[month];
604 }
605
606 // -------------------------------------
607
608 int32_t
yearLength(int32_t year) const609 GregorianCalendar::yearLength(int32_t year) const
610 {
611 return isLeapYear(year) ? 366 : 365;
612 }
613
614 // -------------------------------------
615
616 int32_t
yearLength() const617 GregorianCalendar::yearLength() const
618 {
619 return isLeapYear(internalGet(UCAL_YEAR)) ? 366 : 365;
620 }
621
622 // -------------------------------------
623
624 /**
625 * After adjustments such as add(MONTH), add(YEAR), we don't want the
626 * month to jump around. E.g., we don't want Jan 31 + 1 month to go to Mar
627 * 3, we want it to go to Feb 28. Adjustments which might run into this
628 * problem call this method to retain the proper month.
629 */
630 void
pinDayOfMonth()631 GregorianCalendar::pinDayOfMonth()
632 {
633 int32_t monthLen = monthLength(internalGet(UCAL_MONTH));
634 int32_t dom = internalGet(UCAL_DATE);
635 if(dom > monthLen)
636 set(UCAL_DATE, monthLen);
637 }
638
639 // -------------------------------------
640
641
642 UBool
validateFields() const643 GregorianCalendar::validateFields() const
644 {
645 for (int32_t field = 0; field < UCAL_FIELD_COUNT; field++) {
646 // Ignore DATE and DAY_OF_YEAR which are handled below
647 if (field != UCAL_DATE &&
648 field != UCAL_DAY_OF_YEAR &&
649 isSet((UCalendarDateFields)field) &&
650 ! boundsCheck(internalGet((UCalendarDateFields)field), (UCalendarDateFields)field))
651 return FALSE;
652 }
653
654 // Values differ in Least-Maximum and Maximum should be handled
655 // specially.
656 if (isSet(UCAL_DATE)) {
657 int32_t date = internalGet(UCAL_DATE);
658 if (date < getMinimum(UCAL_DATE) ||
659 date > monthLength(internalGet(UCAL_MONTH))) {
660 return FALSE;
661 }
662 }
663
664 if (isSet(UCAL_DAY_OF_YEAR)) {
665 int32_t days = internalGet(UCAL_DAY_OF_YEAR);
666 if (days < 1 || days > yearLength()) {
667 return FALSE;
668 }
669 }
670
671 // Handle DAY_OF_WEEK_IN_MONTH, which must not have the value zero.
672 // We've checked against minimum and maximum above already.
673 if (isSet(UCAL_DAY_OF_WEEK_IN_MONTH) &&
674 0 == internalGet(UCAL_DAY_OF_WEEK_IN_MONTH)) {
675 return FALSE;
676 }
677
678 return TRUE;
679 }
680
681 // -------------------------------------
682
683 UBool
boundsCheck(int32_t value,UCalendarDateFields field) const684 GregorianCalendar::boundsCheck(int32_t value, UCalendarDateFields field) const
685 {
686 return value >= getMinimum(field) && value <= getMaximum(field);
687 }
688
689 // -------------------------------------
690
691 UDate
getEpochDay(UErrorCode & status)692 GregorianCalendar::getEpochDay(UErrorCode& status)
693 {
694 complete(status);
695 // Divide by 1000 (convert to seconds) in order to prevent overflow when
696 // dealing with UDate(Long.MIN_VALUE) and UDate(Long.MAX_VALUE).
697 double wallSec = internalGetTime()/1000 + (internalGet(UCAL_ZONE_OFFSET) + internalGet(UCAL_DST_OFFSET))/1000;
698
699 return Math::floorDivide(wallSec, kOneDay/1000.0);
700 }
701
702 // -------------------------------------
703
704
705 // -------------------------------------
706
707 /**
708 * Compute the julian day number of the day BEFORE the first day of
709 * January 1, year 1 of the given calendar. If julianDay == 0, it
710 * specifies (Jan. 1, 1) - 1, in whatever calendar we are using (Julian
711 * or Gregorian).
712 */
computeJulianDayOfYear(UBool isGregorian,int32_t year,UBool & isLeap)713 double GregorianCalendar::computeJulianDayOfYear(UBool isGregorian,
714 int32_t year, UBool& isLeap)
715 {
716 isLeap = year%4 == 0;
717 int32_t y = year - 1;
718 double julianDay = 365.0*y + Math::floorDivide(y, 4) + (kJan1_1JulianDay - 3);
719
720 if (isGregorian) {
721 isLeap = isLeap && ((year%100 != 0) || (year%400 == 0));
722 // Add 2 because Gregorian calendar starts 2 days after Julian calendar
723 julianDay += Grego::gregorianShift(year);
724 }
725
726 return julianDay;
727 }
728
729 // /**
730 // * Compute the day of week, relative to the first day of week, from
731 // * 0..6, of the current DOW_LOCAL or DAY_OF_WEEK fields. This is
732 // * equivalent to get(DOW_LOCAL) - 1.
733 // */
734 // int32_t GregorianCalendar::computeRelativeDOW() const {
735 // int32_t relDow = 0;
736 // if (fStamp[UCAL_DOW_LOCAL] > fStamp[UCAL_DAY_OF_WEEK]) {
737 // relDow = internalGet(UCAL_DOW_LOCAL) - 1; // 1-based
738 // } else if (fStamp[UCAL_DAY_OF_WEEK] != kUnset) {
739 // relDow = internalGet(UCAL_DAY_OF_WEEK) - getFirstDayOfWeek();
740 // if (relDow < 0) relDow += 7;
741 // }
742 // return relDow;
743 // }
744
745 // /**
746 // * Compute the day of week, relative to the first day of week,
747 // * from 0..6 of the given julian day.
748 // */
749 // int32_t GregorianCalendar::computeRelativeDOW(double julianDay) const {
750 // int32_t relDow = julianDayToDayOfWeek(julianDay) - getFirstDayOfWeek();
751 // if (relDow < 0) {
752 // relDow += 7;
753 // }
754 // return relDow;
755 // }
756
757 // /**
758 // * Compute the DOY using the WEEK_OF_YEAR field and the julian day
759 // * of the day BEFORE January 1 of a year (a return value from
760 // * computeJulianDayOfYear).
761 // */
762 // int32_t GregorianCalendar::computeDOYfromWOY(double julianDayOfYear) const {
763 // // Compute DOY from day of week plus week of year
764
765 // // Find the day of the week for the first of this year. This
766 // // is zero-based, with 0 being the locale-specific first day of
767 // // the week. Add 1 to get first day of year.
768 // int32_t fdy = computeRelativeDOW(julianDayOfYear + 1);
769
770 // return
771 // // Compute doy of first (relative) DOW of WOY 1
772 // (((7 - fdy) < getMinimalDaysInFirstWeek())
773 // ? (8 - fdy) : (1 - fdy))
774
775 // // Adjust for the week number.
776 // + (7 * (internalGet(UCAL_WEEK_OF_YEAR) - 1))
777
778 // // Adjust for the DOW
779 // + computeRelativeDOW();
780 // }
781
782 // -------------------------------------
783
784 double
millisToJulianDay(UDate millis)785 GregorianCalendar::millisToJulianDay(UDate millis)
786 {
787 return (double)kEpochStartAsJulianDay + Math::floorDivide(millis, (double)kOneDay);
788 }
789
790 // -------------------------------------
791
792 UDate
julianDayToMillis(double julian)793 GregorianCalendar::julianDayToMillis(double julian)
794 {
795 return (UDate) ((julian - kEpochStartAsJulianDay) * (double) kOneDay);
796 }
797
798 // -------------------------------------
799
800 int32_t
aggregateStamp(int32_t stamp_a,int32_t stamp_b)801 GregorianCalendar::aggregateStamp(int32_t stamp_a, int32_t stamp_b)
802 {
803 return (((stamp_a != kUnset && stamp_b != kUnset)
804 ? uprv_max(stamp_a, stamp_b)
805 : (int32_t)kUnset));
806 }
807
808 // -------------------------------------
809
810 /**
811 * Roll a field by a signed amount.
812 * Note: This will be made public later. [LIU]
813 */
814
815 void
roll(EDateFields field,int32_t amount,UErrorCode & status)816 GregorianCalendar::roll(EDateFields field, int32_t amount, UErrorCode& status) {
817 roll((UCalendarDateFields) field, amount, status);
818 }
819
820 void
roll(UCalendarDateFields field,int32_t amount,UErrorCode & status)821 GregorianCalendar::roll(UCalendarDateFields field, int32_t amount, UErrorCode& status)
822 {
823 if((amount == 0) || U_FAILURE(status)) {
824 return;
825 }
826
827 // J81 processing. (gregorian cutover)
828 UBool inCutoverMonth = FALSE;
829 int32_t cMonthLen=0; // 'c' for cutover; in days
830 int32_t cDayOfMonth=0; // no discontinuity: [0, cMonthLen)
831 double cMonthStart=0.0; // in ms
832
833 // Common code - see if we're in the cutover month of the cutover year
834 if(get(UCAL_EXTENDED_YEAR, status) == fGregorianCutoverYear) {
835 switch (field) {
836 case UCAL_DAY_OF_MONTH:
837 case UCAL_WEEK_OF_MONTH:
838 {
839 int32_t max = monthLength(internalGet(UCAL_MONTH));
840 UDate t = internalGetTime();
841 // We subtract 1 from the DAY_OF_MONTH to make it zero-based, and an
842 // additional 10 if we are after the cutover. Thus the monthStart
843 // value will be correct iff we actually are in the cutover month.
844 cDayOfMonth = internalGet(UCAL_DAY_OF_MONTH) - ((t >= fGregorianCutover) ? 10 : 0);
845 cMonthStart = t - ((cDayOfMonth - 1) * kOneDay);
846 // A month containing the cutover is 10 days shorter.
847 if ((cMonthStart < fGregorianCutover) &&
848 (cMonthStart + (cMonthLen=(max-10))*kOneDay >= fGregorianCutover)) {
849 inCutoverMonth = TRUE;
850 }
851 }
852 default:
853 ;
854 }
855 }
856
857 switch (field) {
858 case UCAL_WEEK_OF_YEAR: {
859 // Unlike WEEK_OF_MONTH, WEEK_OF_YEAR never shifts the day of the
860 // week. Also, rolling the week of the year can have seemingly
861 // strange effects simply because the year of the week of year
862 // may be different from the calendar year. For example, the
863 // date Dec 28, 1997 is the first day of week 1 of 1998 (if
864 // weeks start on Sunday and the minimal days in first week is
865 // <= 3).
866 int32_t woy = get(UCAL_WEEK_OF_YEAR, status);
867 // Get the ISO year, which matches the week of year. This
868 // may be one year before or after the calendar year.
869 int32_t isoYear = get(UCAL_YEAR_WOY, status);
870 int32_t isoDoy = internalGet(UCAL_DAY_OF_YEAR);
871 if (internalGet(UCAL_MONTH) == UCAL_JANUARY) {
872 if (woy >= 52) {
873 isoDoy += handleGetYearLength(isoYear);
874 }
875 } else {
876 if (woy == 1) {
877 isoDoy -= handleGetYearLength(isoYear - 1);
878 }
879 }
880 woy += amount;
881 // Do fast checks to avoid unnecessary computation:
882 if (woy < 1 || woy > 52) {
883 // Determine the last week of the ISO year.
884 // We do this using the standard formula we use
885 // everywhere in this file. If we can see that the
886 // days at the end of the year are going to fall into
887 // week 1 of the next year, we drop the last week by
888 // subtracting 7 from the last day of the year.
889 int32_t lastDoy = handleGetYearLength(isoYear);
890 int32_t lastRelDow = (lastDoy - isoDoy + internalGet(UCAL_DAY_OF_WEEK) -
891 getFirstDayOfWeek()) % 7;
892 if (lastRelDow < 0) lastRelDow += 7;
893 if ((6 - lastRelDow) >= getMinimalDaysInFirstWeek()) lastDoy -= 7;
894 int32_t lastWoy = weekNumber(lastDoy, lastRelDow + 1);
895 woy = ((woy + lastWoy - 1) % lastWoy) + 1;
896 }
897 set(UCAL_WEEK_OF_YEAR, woy);
898 set(UCAL_YEAR_WOY,isoYear);
899 return;
900 }
901
902 case UCAL_DAY_OF_MONTH:
903 if( !inCutoverMonth ) {
904 Calendar::roll(field, amount, status);
905 return;
906 } else {
907 // [j81] 1582 special case for DOM
908 // The default computation works except when the current month
909 // contains the Gregorian cutover. We handle this special case
910 // here. [j81 - aliu]
911 double monthLen = cMonthLen * kOneDay;
912 double msIntoMonth = uprv_fmod(internalGetTime() - cMonthStart +
913 amount * kOneDay, monthLen);
914 if (msIntoMonth < 0) {
915 msIntoMonth += monthLen;
916 }
917 #if defined (U_DEBUG_CAL)
918 fprintf(stderr, "%s:%d: roll DOM %d -> %.0lf ms \n",
919 __FILE__, __LINE__,amount, cMonthLen, cMonthStart+msIntoMonth);
920 #endif
921 setTimeInMillis(cMonthStart + msIntoMonth, status);
922 return;
923 }
924
925 case UCAL_WEEK_OF_MONTH:
926 if( !inCutoverMonth ) {
927 Calendar::roll(field, amount, status);
928 return;
929 } else {
930 #if defined (U_DEBUG_CAL)
931 fprintf(stderr, "%s:%d: roll WOM %d ??????????????????? \n",
932 __FILE__, __LINE__,amount);
933 #endif
934 // NOTE: following copied from the old
935 // GregorianCalendar::roll( WEEK_OF_MONTH ) code
936
937 // This is tricky, because during the roll we may have to shift
938 // to a different day of the week. For example:
939
940 // s m t w r f s
941 // 1 2 3 4 5
942 // 6 7 8 9 10 11 12
943
944 // When rolling from the 6th or 7th back one week, we go to the
945 // 1st (assuming that the first partial week counts). The same
946 // thing happens at the end of the month.
947
948 // The other tricky thing is that we have to figure out whether
949 // the first partial week actually counts or not, based on the
950 // minimal first days in the week. And we have to use the
951 // correct first day of the week to delineate the week
952 // boundaries.
953
954 // Here's our algorithm. First, we find the real boundaries of
955 // the month. Then we discard the first partial week if it
956 // doesn't count in this locale. Then we fill in the ends with
957 // phantom days, so that the first partial week and the last
958 // partial week are full weeks. We then have a nice square
959 // block of weeks. We do the usual rolling within this block,
960 // as is done elsewhere in this method. If we wind up on one of
961 // the phantom days that we added, we recognize this and pin to
962 // the first or the last day of the month. Easy, eh?
963
964 // Another wrinkle: To fix jitterbug 81, we have to make all this
965 // work in the oddball month containing the Gregorian cutover.
966 // This month is 10 days shorter than usual, and also contains
967 // a discontinuity in the days; e.g., the default cutover month
968 // is Oct 1582, and goes from day of month 4 to day of month 15.
969
970 // Normalize the DAY_OF_WEEK so that 0 is the first day of the week
971 // in this locale. We have dow in 0..6.
972 int32_t dow = internalGet(UCAL_DAY_OF_WEEK) - getFirstDayOfWeek();
973 if (dow < 0)
974 dow += 7;
975
976 // Find the day of month, compensating for cutover discontinuity.
977 int32_t dom = cDayOfMonth;
978
979 // Find the day of the week (normalized for locale) for the first
980 // of the month.
981 int32_t fdm = (dow - dom + 1) % 7;
982 if (fdm < 0)
983 fdm += 7;
984
985 // Get the first day of the first full week of the month,
986 // including phantom days, if any. Figure out if the first week
987 // counts or not; if it counts, then fill in phantom days. If
988 // not, advance to the first real full week (skip the partial week).
989 int32_t start;
990 if ((7 - fdm) < getMinimalDaysInFirstWeek())
991 start = 8 - fdm; // Skip the first partial week
992 else
993 start = 1 - fdm; // This may be zero or negative
994
995 // Get the day of the week (normalized for locale) for the last
996 // day of the month.
997 int32_t monthLen = cMonthLen;
998 int32_t ldm = (monthLen - dom + dow) % 7;
999 // We know monthLen >= DAY_OF_MONTH so we skip the += 7 step here.
1000
1001 // Get the limit day for the blocked-off rectangular month; that
1002 // is, the day which is one past the last day of the month,
1003 // after the month has already been filled in with phantom days
1004 // to fill out the last week. This day has a normalized DOW of 0.
1005 int32_t limit = monthLen + 7 - ldm;
1006
1007 // Now roll between start and (limit - 1).
1008 int32_t gap = limit - start;
1009 int32_t newDom = (dom + amount*7 - start) % gap;
1010 if (newDom < 0)
1011 newDom += gap;
1012 newDom += start;
1013
1014 // Finally, pin to the real start and end of the month.
1015 if (newDom < 1)
1016 newDom = 1;
1017 if (newDom > monthLen)
1018 newDom = monthLen;
1019
1020 // Set the DAY_OF_MONTH. We rely on the fact that this field
1021 // takes precedence over everything else (since all other fields
1022 // are also set at this point). If this fact changes (if the
1023 // disambiguation algorithm changes) then we will have to unset
1024 // the appropriate fields here so that DAY_OF_MONTH is attended
1025 // to.
1026
1027 // If we are in the cutover month, manipulate ms directly. Don't do
1028 // this in general because it doesn't work across DST boundaries
1029 // (details, details). This takes care of the discontinuity.
1030 setTimeInMillis(cMonthStart + (newDom-1)*kOneDay, status);
1031 return;
1032 }
1033
1034 default:
1035 Calendar::roll(field, amount, status);
1036 return;
1037 }
1038 }
1039
1040 // -------------------------------------
1041
1042
1043 /**
1044 * Return the minimum value that this field could have, given the current date.
1045 * For the Gregorian calendar, this is the same as getMinimum() and getGreatestMinimum().
1046 * @param field the time field.
1047 * @return the minimum value that this field could have, given the current date.
1048 * @deprecated ICU 2.6. Use getActualMinimum(UCalendarDateFields field) instead.
1049 */
getActualMinimum(EDateFields field) const1050 int32_t GregorianCalendar::getActualMinimum(EDateFields field) const
1051 {
1052 return getMinimum((UCalendarDateFields)field);
1053 }
1054
getActualMinimum(EDateFields field,UErrorCode &) const1055 int32_t GregorianCalendar::getActualMinimum(EDateFields field, UErrorCode& /* status */) const
1056 {
1057 return getMinimum((UCalendarDateFields)field);
1058 }
1059
1060 /**
1061 * Return the minimum value that this field could have, given the current date.
1062 * For the Gregorian calendar, this is the same as getMinimum() and getGreatestMinimum().
1063 * @param field the time field.
1064 * @return the minimum value that this field could have, given the current date.
1065 * @draft ICU 2.6.
1066 */
getActualMinimum(UCalendarDateFields field,UErrorCode &) const1067 int32_t GregorianCalendar::getActualMinimum(UCalendarDateFields field, UErrorCode& /* status */) const
1068 {
1069 return getMinimum(field);
1070 }
1071
1072
1073 // ------------------------------------
1074
1075 /**
1076 * Old year limits were least max 292269054, max 292278994.
1077 */
1078
1079 /**
1080 * @stable ICU 2.0
1081 */
handleGetLimit(UCalendarDateFields field,ELimitType limitType) const1082 int32_t GregorianCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const {
1083 return kGregorianCalendarLimits[field][limitType];
1084 }
1085
1086 /**
1087 * Return the maximum value that this field could have, given the current date.
1088 * For example, with the date "Feb 3, 1997" and the DAY_OF_MONTH field, the actual
1089 * maximum would be 28; for "Feb 3, 1996" it s 29. Similarly for a Hebrew calendar,
1090 * for some years the actual maximum for MONTH is 12, and for others 13.
1091 * @stable ICU 2.0
1092 */
getActualMaximum(UCalendarDateFields field,UErrorCode & status) const1093 int32_t GregorianCalendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const
1094 {
1095 /* It is a known limitation that the code here (and in getActualMinimum)
1096 * won't behave properly at the extreme limits of GregorianCalendar's
1097 * representable range (except for the code that handles the YEAR
1098 * field). That's because the ends of the representable range are at
1099 * odd spots in the year. For calendars with the default Gregorian
1100 * cutover, these limits are Sun Dec 02 16:47:04 GMT 292269055 BC to Sun
1101 * Aug 17 07:12:55 GMT 292278994 AD, somewhat different for non-GMT
1102 * zones. As a result, if the calendar is set to Aug 1 292278994 AD,
1103 * the actual maximum of DAY_OF_MONTH is 17, not 30. If the date is Mar
1104 * 31 in that year, the actual maximum month might be Jul, whereas is
1105 * the date is Mar 15, the actual maximum might be Aug -- depending on
1106 * the precise semantics that are desired. Similar considerations
1107 * affect all fields. Nonetheless, this effect is sufficiently arcane
1108 * that we permit it, rather than complicating the code to handle such
1109 * intricacies. - liu 8/20/98
1110
1111 * UPDATE: No longer true, since we have pulled in the limit values on
1112 * the year. - Liu 11/6/00 */
1113
1114 switch (field) {
1115
1116 case UCAL_YEAR:
1117 /* The year computation is no different, in principle, from the
1118 * others, however, the range of possible maxima is large. In
1119 * addition, the way we know we've exceeded the range is different.
1120 * For these reasons, we use the special case code below to handle
1121 * this field.
1122 *
1123 * The actual maxima for YEAR depend on the type of calendar:
1124 *
1125 * Gregorian = May 17, 292275056 BC - Aug 17, 292278994 AD
1126 * Julian = Dec 2, 292269055 BC - Jan 3, 292272993 AD
1127 * Hybrid = Dec 2, 292269055 BC - Aug 17, 292278994 AD
1128 *
1129 * We know we've exceeded the maximum when either the month, date,
1130 * time, or era changes in response to setting the year. We don't
1131 * check for month, date, and time here because the year and era are
1132 * sufficient to detect an invalid year setting. NOTE: If code is
1133 * added to check the month and date in the future for some reason,
1134 * Feb 29 must be allowed to shift to Mar 1 when setting the year.
1135 */
1136 {
1137 if(U_FAILURE(status)) return 0;
1138 Calendar *cal = clone();
1139 if(!cal) {
1140 status = U_MEMORY_ALLOCATION_ERROR;
1141 return 0;
1142 }
1143
1144 cal->setLenient(TRUE);
1145
1146 int32_t era = cal->get(UCAL_ERA, status);
1147 UDate d = cal->getTime(status);
1148
1149 /* Perform a binary search, with the invariant that lowGood is a
1150 * valid year, and highBad is an out of range year.
1151 */
1152 int32_t lowGood = kGregorianCalendarLimits[UCAL_YEAR][1];
1153 int32_t highBad = kGregorianCalendarLimits[UCAL_YEAR][2]+1;
1154 while ((lowGood + 1) < highBad) {
1155 int32_t y = (lowGood + highBad) / 2;
1156 cal->set(UCAL_YEAR, y);
1157 if (cal->get(UCAL_YEAR, status) == y && cal->get(UCAL_ERA, status) == era) {
1158 lowGood = y;
1159 } else {
1160 highBad = y;
1161 cal->setTime(d, status); // Restore original fields
1162 }
1163 }
1164
1165 delete cal;
1166 return lowGood;
1167 }
1168
1169 default:
1170 return Calendar::getActualMaximum(field,status);
1171 }
1172 }
1173
1174
handleGetExtendedYear()1175 int32_t GregorianCalendar::handleGetExtendedYear() {
1176 int32_t year = kEpochYear;
1177 switch(resolveFields(kYearPrecedence)) {
1178 case UCAL_EXTENDED_YEAR:
1179 year = internalGet(UCAL_EXTENDED_YEAR, kEpochYear);
1180 break;
1181
1182 case UCAL_YEAR:
1183 {
1184 // The year defaults to the epoch start, the era to AD
1185 int32_t era = internalGet(UCAL_ERA, AD);
1186 if (era == BC) {
1187 year = 1 - internalGet(UCAL_YEAR, 1); // Convert to extended year
1188 } else {
1189 year = internalGet(UCAL_YEAR, kEpochYear);
1190 }
1191 }
1192 break;
1193
1194 case UCAL_YEAR_WOY:
1195 year = handleGetExtendedYearFromWeekFields(internalGet(UCAL_YEAR_WOY), internalGet(UCAL_WEEK_OF_YEAR));
1196 #if defined (U_DEBUG_CAL)
1197 // if(internalGet(UCAL_YEAR_WOY) != year) {
1198 fprintf(stderr, "%s:%d: hGEYFWF[%d,%d] -> %d\n",
1199 __FILE__, __LINE__,internalGet(UCAL_YEAR_WOY),internalGet(UCAL_WEEK_OF_YEAR),year);
1200 //}
1201 #endif
1202 break;
1203
1204 default:
1205 year = kEpochYear;
1206 }
1207 return year;
1208 }
1209
handleGetExtendedYearFromWeekFields(int32_t yearWoy,int32_t woy)1210 int32_t GregorianCalendar::handleGetExtendedYearFromWeekFields(int32_t yearWoy, int32_t woy)
1211 {
1212 // convert year to extended form
1213 int32_t era = internalGet(UCAL_ERA, AD);
1214 if(era == BC) {
1215 yearWoy = 1 - yearWoy;
1216 }
1217 return Calendar::handleGetExtendedYearFromWeekFields(yearWoy, woy);
1218 }
1219
1220
1221 // -------------------------------------
1222
1223 UBool
inDaylightTime(UErrorCode & status) const1224 GregorianCalendar::inDaylightTime(UErrorCode& status) const
1225 {
1226 if (U_FAILURE(status) || !getTimeZone().useDaylightTime())
1227 return FALSE;
1228
1229 // Force an update of the state of the Calendar.
1230 ((GregorianCalendar*)this)->complete(status); // cast away const
1231
1232 return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE);
1233 }
1234
1235 // -------------------------------------
1236
1237 /**
1238 * Return the ERA. We need a special method for this because the
1239 * default ERA is AD, but a zero (unset) ERA is BC.
1240 */
1241 int32_t
internalGetEra() const1242 GregorianCalendar::internalGetEra() const {
1243 return isSet(UCAL_ERA) ? internalGet(UCAL_ERA) : (int32_t)AD;
1244 }
1245
1246 const char *
getType() const1247 GregorianCalendar::getType() const {
1248 //static const char kGregorianType = "gregorian";
1249
1250 return "gregorian";
1251 }
1252
1253 const UDate GregorianCalendar::fgSystemDefaultCentury = DBL_MIN;
1254 const int32_t GregorianCalendar::fgSystemDefaultCenturyYear = -1;
1255
1256 UDate GregorianCalendar::fgSystemDefaultCenturyStart = DBL_MIN;
1257 int32_t GregorianCalendar::fgSystemDefaultCenturyStartYear = -1;
1258
1259
haveDefaultCentury() const1260 UBool GregorianCalendar::haveDefaultCentury() const
1261 {
1262 return TRUE;
1263 }
1264
defaultCenturyStart() const1265 UDate GregorianCalendar::defaultCenturyStart() const
1266 {
1267 return internalGetDefaultCenturyStart();
1268 }
1269
defaultCenturyStartYear() const1270 int32_t GregorianCalendar::defaultCenturyStartYear() const
1271 {
1272 return internalGetDefaultCenturyStartYear();
1273 }
1274
1275 UDate
internalGetDefaultCenturyStart() const1276 GregorianCalendar::internalGetDefaultCenturyStart() const
1277 {
1278 // lazy-evaluate systemDefaultCenturyStart
1279 UBool needsUpdate;
1280 UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate);
1281
1282 if (needsUpdate) {
1283 initializeSystemDefaultCentury();
1284 }
1285
1286 // use defaultCenturyStart unless it's the flag value;
1287 // then use systemDefaultCenturyStart
1288
1289 return fgSystemDefaultCenturyStart;
1290 }
1291
1292 int32_t
internalGetDefaultCenturyStartYear() const1293 GregorianCalendar::internalGetDefaultCenturyStartYear() const
1294 {
1295 // lazy-evaluate systemDefaultCenturyStartYear
1296 UBool needsUpdate;
1297 UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate);
1298
1299 if (needsUpdate) {
1300 initializeSystemDefaultCentury();
1301 }
1302
1303 // use defaultCenturyStart unless it's the flag value;
1304 // then use systemDefaultCenturyStartYear
1305
1306 return fgSystemDefaultCenturyStartYear;
1307 }
1308
1309 void
initializeSystemDefaultCentury()1310 GregorianCalendar::initializeSystemDefaultCentury()
1311 {
1312 // initialize systemDefaultCentury and systemDefaultCenturyYear based
1313 // on the current time. They'll be set to 80 years before
1314 // the current time.
1315 // No point in locking as it should be idempotent.
1316 if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury)
1317 {
1318 UErrorCode status = U_ZERO_ERROR;
1319 Calendar *calendar = new GregorianCalendar(status);
1320 if (calendar != NULL && U_SUCCESS(status))
1321 {
1322 calendar->setTime(Calendar::getNow(), status);
1323 calendar->add(UCAL_YEAR, -80, status);
1324
1325 UDate newStart = calendar->getTime(status);
1326 int32_t newYear = calendar->get(UCAL_YEAR, status);
1327 {
1328 umtx_lock(NULL);
1329 fgSystemDefaultCenturyStart = newStart;
1330 fgSystemDefaultCenturyStartYear = newYear;
1331 umtx_unlock(NULL);
1332 }
1333 delete calendar;
1334 }
1335 // We have no recourse upon failure unless we want to propagate the failure
1336 // out.
1337 }
1338 }
1339
1340
1341 U_NAMESPACE_END
1342
1343 #endif /* #if !UCONFIG_NO_FORMATTING */
1344
1345 //eof
1346