intl/icu/source/i18n/islamcal.cpp@6474c204b198
intl/icu/source/i18n/islamcal.cpp
Wed, 31 Dec 2014 06:09:35 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:09:35 +0100
- changeset 0
- 6474c204b198
- permissions
- -rw-r--r--
Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.
1 /*
2 ******************************************************************************
3 * Copyright (C) 2003-2013, International Business Machines Corporation
4 * and others. All Rights Reserved.
5 ******************************************************************************
6 *
7 * File ISLAMCAL.H
8 *
9 * Modification History:
10 *
11 * Date Name Description
12 * 10/14/2003 srl ported from java IslamicCalendar
13 *****************************************************************************
14 */
16 #include "islamcal.h"
18 #if !UCONFIG_NO_FORMATTING
20 #include "umutex.h"
21 #include <float.h>
22 #include "gregoimp.h" // Math
23 #include "astro.h" // CalendarAstronomer
24 #include "uhash.h"
25 #include "ucln_in.h"
26 #include "uassert.h"
28 static const UDate HIJRA_MILLIS = -42521587200000.0; // 7/16/622 AD 00:00
30 // Debugging
31 #ifdef U_DEBUG_ISLAMCAL
32 # include <stdio.h>
33 # include <stdarg.h>
34 static void debug_islamcal_loc(const char *f, int32_t l)
35 {
36 fprintf(stderr, "%s:%d: ", f, l);
37 }
39 static void debug_islamcal_msg(const char *pat, ...)
40 {
41 va_list ap;
42 va_start(ap, pat);
43 vfprintf(stderr, pat, ap);
44 fflush(stderr);
45 }
46 // must use double parens, i.e.: U_DEBUG_ISLAMCAL_MSG(("four is: %d",4));
47 #define U_DEBUG_ISLAMCAL_MSG(x) {debug_islamcal_loc(__FILE__,__LINE__);debug_islamcal_msg x;}
48 #else
49 #define U_DEBUG_ISLAMCAL_MSG(x)
50 #endif
53 // --- The cache --
54 // cache of months
55 static UMutex astroLock = U_MUTEX_INITIALIZER; // pod bay door lock
56 static icu::CalendarCache *gMonthCache = NULL;
57 static icu::CalendarAstronomer *gIslamicCalendarAstro = NULL;
59 U_CDECL_BEGIN
60 static UBool calendar_islamic_cleanup(void) {
61 if (gMonthCache) {
62 delete gMonthCache;
63 gMonthCache = NULL;
64 }
65 if (gIslamicCalendarAstro) {
66 delete gIslamicCalendarAstro;
67 gIslamicCalendarAstro = NULL;
68 }
69 return TRUE;
70 }
71 U_CDECL_END
73 U_NAMESPACE_BEGIN
75 // Implementation of the IslamicCalendar class
77 /**
78 * Friday EPOC
79 */
80 static const int32_t CIVIL_EPOC = 1948440;
82 /**
83 * Thursday EPOC
84 */
85 static const int32_t ASTRONOMICAL_EPOC = 1948439;
88 static const int32_t UMALQURA_YEAR_START = 1318;
89 static const int32_t UMALQURA_YEAR_END = 1480;
91 static const int UMALQURA_MONTHLENGTH[] = {
92 //* 1318 -1322 */ "0101 0111 0100", "1001 0111 0110", "0100 1011 0111", "0010 0101 0111", "0101 0010 1011",
93 0x0574, 0x0975, 0x06A7, 0x0257, 0x052B,
94 //* 1323 -1327 */ "0110 1001 0101", "0110 1100 1010", "1010 1101 0101", "0101 0101 1011", "0010 0101 1101",
95 0x0695, 0x06CA, 0x0AD5, 0x055B, 0x025B,
96 //* 1328 -1332 */ "1001 0010 1101", "1100 1001 0101", "1101 0100 1010", "1110 1010 0101", "0110 1101 0010",
97 0x092D, 0x0C95, 0x0D4A, 0x0E5B, 0x025B,
98 //* 1333 -1337 */ "1010 1101 0101", "0101 0101 1010", "1010 1010 1011", "0100 0100 1011", "0110 1010 0101",
99 0x0AD5, 0x055A, 0x0AAB, 0x044B, 0x06A5,
100 //* 1338 -1342 */ "0111 0101 0010", "1011 1010 1001", "0011 0111 0100", "1010 1011 0110", "0101 0101 0110",
101 0x0752, 0x0BA9, 0x0374, 0x0AB6, 0x0556,
102 //* 1343 -1347 */ "1010 1010 1010", "1101 0101 0010", "1101 1010 1001", "0101 1101 0100", "1010 1110 1010",
103 0x0AAA, 0x0D52, 0x0DA9, 0x05D4, 0x0AEA,
104 //* 1348 -1352 */ "0100 1101 1101", "0010 0110 1110", "1001 0010 1110", "1010 1010 0110", "1101 0101 0100",
105 0x04DD, 0x026E, 0x092E, 0x0AA6, 0x0D54,
106 //* 1353 -1357 */ "0101 1010 1010", "0101 1011 0101", "0010 1011 0100", "1001 0011 0111", "0100 1001 1011",
107 0x05AA, 0x05B5, 0x02B4, 0x0937, 0x049B,
108 //* 1358 -1362 */ "1010 0100 1011", "1011 0010 0101", "1011 0101 0100", "1011 0110 1010", "0101 0110 1101",
109 0x0A4B, 0x0B25, 0x0B54, 0x0B6A, 0x056D,
110 //* 1363 -1367 */ "0100 1010 1101", "1010 0101 0101", "1101 0010 0101", "1110 1001 0010", "1110 1100 1001",
111 0x04AD, 0x0A55, 0x0D25, 0x0E92, 0x0EC9,
112 //* 1368 -1372 */ "0110 1101 0100", "1010 1110 1010", "0101 0110 1011", "0100 1010 1011", "0110 1000 0101",
113 0x06D4, 0x0ADA, 0x056B, 0x04AB, 0x0685,
114 //* 1373 -1377 */ "1011 0100 1001", "1011 1010 0100", "1011 1011 0010", "0101 1011 0101", "0010 1011 1010",
115 0x0B49, 0x0BA4, 0x0BB2, 0x05B5, 0x02BA,
116 //* 1378 -1382 */ "1001 0101 1011", "0100 1010 1011", "0101 0101 0101", "0110 1011 0010", "0110 1101 1001",
117 0x095B, 0x04AB, 0x0555, 0x06B2, 0x06D9,
118 //* 1383 -1387 */ "0010 1110 1100", "1001 0110 1110", "0100 1010 1110", "1010 0101 0110", "1101 0010 1010",
119 0x02EC, 0x096E, 0x04AE, 0x0A56, 0x0D2A,
120 //* 1388 -1392 */ "1101 0101 0101", "0101 1010 1010", "1010 1011 0101", "0100 1011 1011", "0000 0101 1011",
121 0x0D55, 0x05AA, 0x0AB5, 0x04BB, 0x005B,
122 //* 1393 -1397 */ "1001 0010 1011", "1010 1001 0101", "0011 0100 1010", "1011 1010 0101", "0101 1010 1010",
123 0x092B, 0x0A95, 0x034A, 0x0BA5, 0x05AA,
124 //* 1398 -1402 */ "1010 1011 0101", "0101 0101 0110", "1010 1001 0110", "1101 0100 1010", "1110 1010 0101",
125 0x0AB5, 0x0556, 0x0A96, 0x0B4A, 0x0EA5,
126 //* 1403 -1407 */ "0111 0101 0010", "0110 1110 1001", "0011 0110 1010", "1010 1010 1101", "0101 0101 0101",
127 0x0752, 0x06E9, 0x036A, 0x0AAD, 0x0555,
128 //* 1408 -1412 */ "1010 1010 0101", "1011 0101 0010", "1011 1010 1001", "0101 1011 0100", "1001 1011 1010",
129 0x0AA5, 0x0B52, 0x0BA9, 0x05B4, 0x09BA,
130 //* 1413 -1417 */ "0100 1101 1011", "0010 0101 1101", "0101 0010 1101", "1010 1010 0101", "1010 1101 0100",
131 0x04DB, 0x025D, 0x052D, 0x0AA5, 0x0AD4,
132 //* 1418 -1422 */ "1010 1110 1010", "0101 0110 1101", "0100 1011 1101", "0010 0011 1101", "1001 0001 1101",
133 0x0AEA, 0x056D, 0x04BD, 0x023D, 0x091D,
134 //* 1423 -1427 */ "1010 1001 0101", "1011 0100 1010", "1011 0101 1010", "0101 0110 1101", "0010 1011 0110",
135 0x0A95, 0x0B4A, 0x0B5A, 0x056D, 0x02B6,
136 //* 1428 -1432 */ "1001 0011 1011", "0100 1001 1011", "0110 0101 0101", "0110 1010 1001", "0111 0101 0100",
137 0x093B, 0x049B, 0x0655, 0x06A9, 0x0754,
138 //* 1433 -1437 */ "1011 0110 1010", "0101 0110 1100", "1010 1010 1101", "0101 0101 0101", "1011 0010 1001",
139 0x0B6A, 0x056C, 0x0AAD, 0x0555, 0x0B29,
140 //* 1438 -1442 */ "1011 1001 0010", "1011 1010 1001", "0101 1101 0100", "1010 1101 1010", "0101 0101 1010",
141 0x0B92, 0x0BA9, 0x05D4, 0x0ADA, 0x055A,
142 //* 1443 -1447 */ "1010 1010 1011", "0101 1001 0101", "0111 0100 1001", "0111 0110 0100", "1011 1010 1010",
143 0x0AAB, 0x0595, 0x0749, 0x0764, 0x0BAA,
144 //* 1448 -1452 */ "0101 1011 0101", "0010 1011 0110", "1010 0101 0110", "1110 0100 1101", "1011 0010 0101",
145 0x05B5, 0x02B6, 0x0A56, 0x0E4D, 0x0B25,
146 //* 1453 -1457 */ "1011 0101 0010", "1011 0110 1010", "0101 1010 1101", "0010 1010 1110", "1001 0010 1111",
147 0x0B52, 0x0B6A, 0x05AD, 0x02AE, 0x092F,
148 //* 1458 -1462 */ "0100 1001 0111", "0110 0100 1011", "0110 1010 0101", "0110 1010 1100", "1010 1101 0110",
149 0x0497, 0x064B, 0x06A5, 0x06AC, 0x0AD6,
150 //* 1463 -1467 */ "0101 0101 1101", "0100 1001 1101", "1010 0100 1101", "1101 0001 0110", "1101 1001 0101",
151 0x055D, 0x049D, 0x0A4D, 0x0D16, 0x0D95,
152 //* 1468 -1472 */ "0101 1010 1010", "0101 1011 0101", "0010 1001 1010", "1001 0101 1011", "0100 1010 1100",
153 0x05AA, 0x05B5, 0x029A, 0x095B, 0x04AC,
154 //* 1473 -1477 */ "0101 1001 0101", "0110 1100 1010", "0110 1110 0100", "1010 1110 1010", "0100 1111 0101",
155 0x0595, 0x06CA, 0x06E4, 0x0AEA, 0x04F5,
156 //* 1478 -1480 */ "0010 1011 0110", "1001 0101 0110", "1010 1010 1010"
157 0x02B6, 0x0956, 0x0AAA
158 };
160 int32_t getUmalqura_MonthLength(int32_t y, int32_t m) {
161 int32_t mask = (int32_t) (0x01 << (11 - m)); // set mask for bit corresponding to month
162 if((UMALQURA_MONTHLENGTH[y] & mask) == 0 )
163 return 29;
164 else
165 return 30;
167 }
169 //-------------------------------------------------------------------------
170 // Constructors...
171 //-------------------------------------------------------------------------
173 const char *IslamicCalendar::getType() const {
174 const char *sType = NULL;
176 switch (cType) {
177 case CIVIL:
178 sType = "islamic-civil";
179 break;
180 case ASTRONOMICAL:
181 sType = "islamic";
182 break;
183 case TBLA:
184 sType = "islamic-tbla";
185 break;
186 case UMALQURA:
187 sType = "islamic-umalqura";
188 break;
189 default:
190 U_ASSERT(false); // out of range
191 sType = "islamic"; // "islamic" is used as the generic type
192 break;
193 }
194 return sType;
195 }
197 Calendar* IslamicCalendar::clone() const {
198 return new IslamicCalendar(*this);
199 }
201 IslamicCalendar::IslamicCalendar(const Locale& aLocale, UErrorCode& success, ECalculationType type)
202 : Calendar(TimeZone::createDefault(), aLocale, success),
203 cType(type)
204 {
205 setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
206 }
208 IslamicCalendar::IslamicCalendar(const IslamicCalendar& other) : Calendar(other), cType(other.cType) {
209 }
211 IslamicCalendar::~IslamicCalendar()
212 {
213 }
215 void IslamicCalendar::setCalculationType(ECalculationType type, UErrorCode &status)
216 {
217 if (cType != type) {
218 // The fields of the calendar will become invalid, because the calendar
219 // rules are different
220 UDate m = getTimeInMillis(status);
221 cType = type;
222 clear();
223 setTimeInMillis(m, status);
224 }
225 }
227 /**
228 * Returns <code>true</code> if this object is using the fixed-cycle civil
229 * calendar, or <code>false</code> if using the religious, astronomical
230 * calendar.
231 * @draft ICU 2.4
232 */
233 UBool IslamicCalendar::isCivil() {
234 return (cType == CIVIL);
235 }
237 //-------------------------------------------------------------------------
238 // Minimum / Maximum access functions
239 //-------------------------------------------------------------------------
241 // Note: Current IslamicCalendar implementation does not work
242 // well with negative years.
244 // TODO: In some cases the current ICU Islamic calendar implementation shows
245 // a month as having 31 days. Since date parsing now uses range checks based
246 // on the table below, we need to change the range for last day of month to
247 // include 31 as a workaround until the implementation is fixed.
248 static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = {
249 // Minimum Greatest Least Maximum
250 // Minimum Maximum
251 { 0, 0, 0, 0}, // ERA
252 { 1, 1, 5000000, 5000000}, // YEAR
253 { 0, 0, 11, 11}, // MONTH
254 { 1, 1, 50, 51}, // WEEK_OF_YEAR
255 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // WEEK_OF_MONTH
256 { 1, 1, 29, 31}, // DAY_OF_MONTH - 31 to workaround for cal implementation bug, should be 30
257 { 1, 1, 354, 355}, // DAY_OF_YEAR
258 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DAY_OF_WEEK
259 { -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH
260 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // AM_PM
261 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR
262 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR_OF_DAY
263 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MINUTE
264 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // SECOND
265 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECOND
266 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // ZONE_OFFSET
267 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DST_OFFSET
268 { 1, 1, 5000000, 5000000}, // YEAR_WOY
269 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DOW_LOCAL
270 { 1, 1, 5000000, 5000000}, // EXTENDED_YEAR
271 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // JULIAN_DAY
272 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECONDS_IN_DAY
273 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // IS_LEAP_MONTH
274 };
276 /**
277 * @draft ICU 2.4
278 */
279 int32_t IslamicCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const {
280 return LIMITS[field][limitType];
281 }
283 //-------------------------------------------------------------------------
284 // Assorted calculation utilities
285 //
287 /**
288 * Determine whether a year is a leap year in the Islamic civil calendar
289 */
290 UBool IslamicCalendar::civilLeapYear(int32_t year)
291 {
292 return (14 + 11 * year) % 30 < 11;
293 }
295 /**
296 * Return the day # on which the given year starts. Days are counted
297 * from the Hijri epoch, origin 0.
298 */
299 int32_t IslamicCalendar::yearStart(int32_t year) const{
300 if (cType == CIVIL || cType == TBLA ||
301 (cType == UMALQURA && year < UMALQURA_YEAR_START))
302 {
303 return (year-1)*354 + ClockMath::floorDivide((3+11*year),30);
304 } else if(cType==ASTRONOMICAL){
305 return trueMonthStart(12*(year-1));
306 } else {
307 int32_t ys = yearStart(UMALQURA_YEAR_START-1);
308 ys+= handleGetYearLength(UMALQURA_YEAR_START-1);
309 for(int i=UMALQURA_YEAR_START; i< year; i++){
310 ys+= handleGetYearLength(i);
311 }
312 return ys;
313 }
314 }
316 /**
317 * Return the day # on which the given month starts. Days are counted
318 * from the Hijri epoch, origin 0.
319 *
320 * @param year The hijri year
321 * @param year The hijri month, 0-based
322 */
323 int32_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {
324 if (cType == CIVIL || cType == TBLA) {
325 return (int32_t)uprv_ceil(29.5*month)
326 + (year-1)*354 + (int32_t)ClockMath::floorDivide((3+11*year),30);
327 } else if(cType==ASTRONOMICAL){
328 return trueMonthStart(12*(year-1) + month);
329 } else {
330 int32_t ms = yearStart(year);
331 for(int i=0; i< month; i++){
332 ms+= handleGetMonthLength(year, i);
333 }
334 return ms;
335 }
336 }
338 /**
339 * Find the day number on which a particular month of the true/lunar
340 * Islamic calendar starts.
341 *
342 * @param month The month in question, origin 0 from the Hijri epoch
343 *
344 * @return The day number on which the given month starts.
345 */
346 int32_t IslamicCalendar::trueMonthStart(int32_t month) const
347 {
348 UErrorCode status = U_ZERO_ERROR;
349 int32_t start = CalendarCache::get(&gMonthCache, month, status);
351 if (start==0) {
352 // Make a guess at when the month started, using the average length
353 UDate origin = HIJRA_MILLIS
354 + uprv_floor(month * CalendarAstronomer::SYNODIC_MONTH) * kOneDay;
356 // moonAge will fail due to memory allocation error
357 double age = moonAge(origin, status);
358 if (U_FAILURE(status)) {
359 goto trueMonthStartEnd;
360 }
362 if (age >= 0) {
363 // The month has already started
364 do {
365 origin -= kOneDay;
366 age = moonAge(origin, status);
367 if (U_FAILURE(status)) {
368 goto trueMonthStartEnd;
369 }
370 } while (age >= 0);
371 }
372 else {
373 // Preceding month has not ended yet.
374 do {
375 origin += kOneDay;
376 age = moonAge(origin, status);
377 if (U_FAILURE(status)) {
378 goto trueMonthStartEnd;
379 }
380 } while (age < 0);
381 }
382 start = (int32_t)ClockMath::floorDivide((origin - HIJRA_MILLIS), (double)kOneDay) + 1;
383 CalendarCache::put(&gMonthCache, month, start, status);
384 }
385 trueMonthStartEnd :
386 if(U_FAILURE(status)) {
387 start = 0;
388 }
389 return start;
390 }
392 /**
393 * Return the "age" of the moon at the given time; this is the difference
394 * in ecliptic latitude between the moon and the sun. This method simply
395 * calls CalendarAstronomer.moonAge, converts to degrees,
396 * and adjusts the result to be in the range [-180, 180].
397 *
398 * @param time The time at which the moon's age is desired,
399 * in millis since 1/1/1970.
400 */
401 double IslamicCalendar::moonAge(UDate time, UErrorCode &status)
402 {
403 double age = 0;
405 umtx_lock(&astroLock);
406 if(gIslamicCalendarAstro == NULL) {
407 gIslamicCalendarAstro = new CalendarAstronomer();
408 if (gIslamicCalendarAstro == NULL) {
409 status = U_MEMORY_ALLOCATION_ERROR;
410 return age;
411 }
412 ucln_i18n_registerCleanup(UCLN_I18N_ISLAMIC_CALENDAR, calendar_islamic_cleanup);
413 }
414 gIslamicCalendarAstro->setTime(time);
415 age = gIslamicCalendarAstro->getMoonAge();
416 umtx_unlock(&astroLock);
418 // Convert to degrees and normalize...
419 age = age * 180 / CalendarAstronomer::PI;
420 if (age > 180) {
421 age = age - 360;
422 }
424 return age;
425 }
427 //----------------------------------------------------------------------
428 // Calendar framework
429 //----------------------------------------------------------------------
431 /**
432 * Return the length (in days) of the given month.
433 *
434 * @param year The hijri year
435 * @param year The hijri month, 0-based
436 * @draft ICU 2.4
437 */
438 int32_t IslamicCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const {
440 int32_t length = 0;
442 if (cType == CIVIL || cType == TBLA ||
443 (cType == UMALQURA && (extendedYear<UMALQURA_YEAR_START || extendedYear>UMALQURA_YEAR_END)) ) {
444 length = 29 + (month+1) % 2;
445 if (month == DHU_AL_HIJJAH && civilLeapYear(extendedYear)) {
446 length++;
447 }
448 } else if(cType == ASTRONOMICAL){
449 month = 12*(extendedYear-1) + month;
450 length = trueMonthStart(month+1) - trueMonthStart(month) ;
451 } else {
452 length = getUmalqura_MonthLength(extendedYear - UMALQURA_YEAR_START, month);
453 }
454 return length;
455 }
457 /**
458 * Return the number of days in the given Islamic year
459 * @draft ICU 2.4
460 */
461 int32_t IslamicCalendar::handleGetYearLength(int32_t extendedYear) const {
462 if (cType == CIVIL || cType == TBLA ||
463 (cType == UMALQURA && (extendedYear<UMALQURA_YEAR_START || extendedYear>UMALQURA_YEAR_END)) ) {
464 return 354 + (civilLeapYear(extendedYear) ? 1 : 0);
465 } else if(cType == ASTRONOMICAL){
466 int32_t month = 12*(extendedYear-1);
467 return (trueMonthStart(month + 12) - trueMonthStart(month));
468 } else {
469 int len = 0;
470 for(int i=0; i<12; i++)
471 len += handleGetMonthLength(extendedYear, i);
472 return len;
473 }
474 }
476 //-------------------------------------------------------------------------
477 // Functions for converting from field values to milliseconds....
478 //-------------------------------------------------------------------------
480 // Return JD of start of given month/year
481 /**
482 * @draft ICU 2.4
483 */
484 int32_t IslamicCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */) const {
485 return monthStart(eyear, month) + 1948439;
486 }
488 //-------------------------------------------------------------------------
489 // Functions for converting from milliseconds to field values
490 //-------------------------------------------------------------------------
492 /**
493 * @draft ICU 2.4
494 */
495 int32_t IslamicCalendar::handleGetExtendedYear() {
496 int32_t year;
497 if (newerField(UCAL_EXTENDED_YEAR, UCAL_YEAR) == UCAL_EXTENDED_YEAR) {
498 year = internalGet(UCAL_EXTENDED_YEAR, 1); // Default to year 1
499 } else {
500 year = internalGet(UCAL_YEAR, 1); // Default to year 1
501 }
502 return year;
503 }
505 /**
506 * Override Calendar to compute several fields specific to the Islamic
507 * calendar system. These are:
508 *
509 * <ul><li>ERA
510 * <li>YEAR
511 * <li>MONTH
512 * <li>DAY_OF_MONTH
513 * <li>DAY_OF_YEAR
514 * <li>EXTENDED_YEAR</ul>
515 *
516 * The DAY_OF_WEEK and DOW_LOCAL fields are already set when this
517 * method is called. The getGregorianXxx() methods return Gregorian
518 * calendar equivalents for the given Julian day.
519 * @draft ICU 2.4
520 */
521 void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
522 int32_t year, month, dayOfMonth, dayOfYear;
523 UDate startDate;
524 int32_t days = julianDay - CIVIL_EPOC;
526 if (cType == CIVIL || cType == TBLA) {
527 if(cType == TBLA)
528 days = julianDay - ASTRONOMICAL_EPOC;
529 // Use the civil calendar approximation, which is just arithmetic
530 year = (int)ClockMath::floorDivide( (double)(30 * days + 10646) , 10631.0 );
531 month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
532 month = month<11?month:11;
533 startDate = monthStart(year, month);
534 } else if(cType == ASTRONOMICAL){
535 // Guess at the number of elapsed full months since the epoch
536 int32_t months = (int32_t)uprv_floor((double)days / CalendarAstronomer::SYNODIC_MONTH);
538 startDate = uprv_floor(months * CalendarAstronomer::SYNODIC_MONTH);
540 double age = moonAge(internalGetTime(), status);
541 if (U_FAILURE(status)) {
542 status = U_MEMORY_ALLOCATION_ERROR;
543 return;
544 }
545 if ( days - startDate >= 25 && age > 0) {
546 // If we're near the end of the month, assume next month and search backwards
547 months++;
548 }
550 // Find out the last time that the new moon was actually visible at this longitude
551 // This returns midnight the night that the moon was visible at sunset.
552 while ((startDate = trueMonthStart(months)) > days) {
553 // If it was after the date in question, back up a month and try again
554 months--;
555 }
557 year = months / 12 + 1;
558 month = months % 12;
559 } else if(cType == UMALQURA) {
560 int32_t umalquraStartdays = yearStart(UMALQURA_YEAR_START) ;
561 if( days < umalquraStartdays){
562 //Use Civil calculation
563 year = (int)ClockMath::floorDivide( (double)(30 * days + 10646) , 10631.0 );
564 month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
565 month = month<11?month:11;
566 startDate = monthStart(year, month);
567 }else{
568 int y =UMALQURA_YEAR_START-1, m =0;
569 long d = 1;
570 while(d > 0){
571 y++;
572 d = days - yearStart(y) +1;
573 if(d == handleGetYearLength(y)){
574 m=11;
575 break;
576 }else if(d < handleGetYearLength(y) ){
577 int monthLen = handleGetMonthLength(y, m);
578 m=0;
579 while(d > monthLen){
580 d -= monthLen;
581 m++;
582 monthLen = handleGetMonthLength(y, m);
583 }
584 break;
585 }
586 }
587 year = y;
588 month = m;
589 }
590 } else { // invalid 'civil'
591 U_ASSERT(false); // should not get here, out of range
592 year=month=0;
593 }
595 dayOfMonth = (days - monthStart(year, month)) + 1;
597 // Now figure out the day of the year.
598 dayOfYear = (days - monthStart(year, 0) + 1);
601 internalSet(UCAL_ERA, 0);
602 internalSet(UCAL_YEAR, year);
603 internalSet(UCAL_EXTENDED_YEAR, year);
604 internalSet(UCAL_MONTH, month);
605 internalSet(UCAL_DAY_OF_MONTH, dayOfMonth);
606 internalSet(UCAL_DAY_OF_YEAR, dayOfYear);
607 }
609 UBool
610 IslamicCalendar::inDaylightTime(UErrorCode& status) const
611 {
612 // copied from GregorianCalendar
613 if (U_FAILURE(status) || (&(getTimeZone()) == NULL && !getTimeZone().useDaylightTime()))
614 return FALSE;
616 // Force an update of the state of the Calendar.
617 ((IslamicCalendar*)this)->complete(status); // cast away const
619 return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE);
620 }
622 /**
623 * The system maintains a static default century start date and Year. They are
624 * initialized the first time they are used. Once the system default century date
625 * and year are set, they do not change.
626 */
627 static UDate gSystemDefaultCenturyStart = DBL_MIN;
628 static int32_t gSystemDefaultCenturyStartYear = -1;
629 static icu::UInitOnce gSystemDefaultCenturyInit = U_INITONCE_INITIALIZER;
632 UBool IslamicCalendar::haveDefaultCentury() const
633 {
634 return TRUE;
635 }
637 UDate IslamicCalendar::defaultCenturyStart() const
638 {
639 // lazy-evaluate systemDefaultCenturyStart
640 umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
641 return gSystemDefaultCenturyStart;
642 }
644 int32_t IslamicCalendar::defaultCenturyStartYear() const
645 {
646 // lazy-evaluate systemDefaultCenturyStartYear
647 umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
648 return gSystemDefaultCenturyStartYear;
649 }
652 void U_CALLCONV
653 IslamicCalendar::initializeSystemDefaultCentury()
654 {
655 // initialize systemDefaultCentury and systemDefaultCenturyYear based
656 // on the current time. They'll be set to 80 years before
657 // the current time.
658 UErrorCode status = U_ZERO_ERROR;
659 IslamicCalendar calendar(Locale("@calendar=islamic-civil"),status);
660 if (U_SUCCESS(status)) {
661 calendar.setTime(Calendar::getNow(), status);
662 calendar.add(UCAL_YEAR, -80, status);
664 gSystemDefaultCenturyStart = calendar.getTime(status);
665 gSystemDefaultCenturyStartYear = calendar.get(UCAL_YEAR, status);
666 }
667 // We have no recourse upon failure unless we want to propagate the failure
668 // out.
669 }
673 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IslamicCalendar)
675 U_NAMESPACE_END
677 #endif
