1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ******************************************************************************
5 * Copyright (C) 2003-2015, International Business Machines Corporation
6 * and others. All Rights Reserved.
7 ******************************************************************************
8 *
9 * File ISLAMCAL.H
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 10/14/2003 srl ported from java IslamicCalendar
15 *****************************************************************************
16 */
17
18 #include "islamcal.h"
19
20 #if !UCONFIG_NO_FORMATTING
21
22 #include "umutex.h"
23 #include <float.h>
24 #include "gregoimp.h" // Math
25 #include "astro.h" // CalendarAstronomer
26 #include "uhash.h"
27 #include "ucln_in.h"
28 #include "uassert.h"
29
30 static const UDate HIJRA_MILLIS = -42521587200000.0; // 7/16/622 AD 00:00
31
32 // Debugging
33 #ifdef U_DEBUG_ISLAMCAL
34 # include <stdio.h>
35 # include <stdarg.h>
debug_islamcal_loc(const char * f,int32_t l)36 static void debug_islamcal_loc(const char *f, int32_t l)
37 {
38 fprintf(stderr, "%s:%d: ", f, l);
39 }
40
debug_islamcal_msg(const char * pat,...)41 static void debug_islamcal_msg(const char *pat, ...)
42 {
43 va_list ap;
44 va_start(ap, pat);
45 vfprintf(stderr, pat, ap);
46 fflush(stderr);
47 }
48 // must use double parens, i.e.: U_DEBUG_ISLAMCAL_MSG(("four is: %d",4));
49 #define U_DEBUG_ISLAMCAL_MSG(x) {debug_islamcal_loc(__FILE__,__LINE__);debug_islamcal_msg x;}
50 #else
51 #define U_DEBUG_ISLAMCAL_MSG(x)
52 #endif
53
54
55 // --- The cache --
56 // cache of months
57 static UMutex astroLock = U_MUTEX_INITIALIZER; // pod bay door lock
58 static icu::CalendarCache *gMonthCache = NULL;
59 static icu::CalendarAstronomer *gIslamicCalendarAstro = NULL;
60
61 U_CDECL_BEGIN
calendar_islamic_cleanup(void)62 static UBool calendar_islamic_cleanup(void) {
63 if (gMonthCache) {
64 delete gMonthCache;
65 gMonthCache = NULL;
66 }
67 if (gIslamicCalendarAstro) {
68 delete gIslamicCalendarAstro;
69 gIslamicCalendarAstro = NULL;
70 }
71 return TRUE;
72 }
73 U_CDECL_END
74
75 U_NAMESPACE_BEGIN
76
77 // Implementation of the IslamicCalendar class
78
79 /**
80 * Friday EPOC
81 */
82 static const int32_t CIVIL_EPOC = 1948440; // CE 622 July 16 Friday (Julian calendar) / CE 622 July 19 (Gregorian calendar)
83
84 /**
85 * Thursday EPOC
86 */
87 static const int32_t ASTRONOMICAL_EPOC = 1948439; // CE 622 July 15 Thursday (Julian calendar)
88
89
90 static const int32_t UMALQURA_YEAR_START = 1300;
91 static const int32_t UMALQURA_YEAR_END = 1600;
92
93 static const int UMALQURA_MONTHLENGTH[] = {
94 //* 1300 -1302 */ "1010 1010 1010", "1101 0101 0100", "1110 1100 1001",
95 0x0AAA, 0x0D54, 0x0EC9,
96 //* 1303 -1307 */ "0110 1101 0100", "0110 1110 1010", "0011 0110 1100", "1010 1010 1101", "0101 0101 0101",
97 0x06D4, 0x06EA, 0x036C, 0x0AAD, 0x0555,
98 //* 1308 -1312 */ "0110 1010 1001", "0111 1001 0010", "1011 1010 1001", "0101 1101 0100", "1010 1101 1010",
99 0x06A9, 0x0792, 0x0BA9, 0x05D4, 0x0ADA,
100 //* 1313 -1317 */ "0101 0101 1100", "1101 0010 1101", "0110 1001 0101", "0111 0100 1010", "1011 0101 0100",
101 0x055C, 0x0D2D, 0x0695, 0x074A, 0x0B54,
102 //* 1318 -1322 */ "1011 0110 1010", "0101 1010 1101", "0100 1010 1110", "1010 0100 1111", "0101 0001 0111",
103 0x0B6A, 0x05AD, 0x04AE, 0x0A4F, 0x0517,
104 //* 1323 -1327 */ "0110 1000 1011", "0110 1010 0101", "1010 1101 0101", "0010 1101 0110", "1001 0101 1011",
105 0x068B, 0x06A5, 0x0AD5, 0x02D6, 0x095B,
106 //* 1328 -1332 */ "0100 1001 1101", "1010 0100 1101", "1101 0010 0110", "1101 1001 0101", "0101 1010 1100",
107 0x049D, 0x0A4D, 0x0D26, 0x0D95, 0x05AC,
108 //* 1333 -1337 */ "1001 1011 0110", "0010 1011 1010", "1010 0101 1011", "0101 0010 1011", "1010 1001 0101",
109 0x09B6, 0x02BA, 0x0A5B, 0x052B, 0x0A95,
110 //* 1338 -1342 */ "0110 1100 1010", "1010 1110 1001", "0010 1111 0100", "1001 0111 0110", "0010 1011 0110",
111 0x06CA, 0x0AE9, 0x02F4, 0x0976, 0x02B6,
112 //* 1343 -1347 */ "1001 0101 0110", "1010 1100 1010", "1011 1010 0100", "1011 1101 0010", "0101 1101 1001",
113 0x0956, 0x0ACA, 0x0BA4, 0x0BD2, 0x05D9,
114 //* 1348 -1352 */ "0010 1101 1100", "1001 0110 1101", "0101 0100 1101", "1010 1010 0101", "1011 0101 0010",
115 0x02DC, 0x096D, 0x054D, 0x0AA5, 0x0B52,
116 //* 1353 -1357 */ "1011 1010 0101", "0101 1011 0100", "1001 1011 0110", "0101 0101 0111", "0010 1001 0111",
117 0x0BA5, 0x05B4, 0x09B6, 0x0557, 0x0297,
118 //* 1358 -1362 */ "0101 0100 1011", "0110 1010 0011", "0111 0101 0010", "1011 0110 0101", "0101 0110 1010",
119 0x054B, 0x06A3, 0x0752, 0x0B65, 0x056A,
120 //* 1363 -1367 */ "1010 1010 1011", "0101 0010 1011", "1100 1001 0101", "1101 0100 1010", "1101 1010 0101",
121 0x0AAB, 0x052B, 0x0C95, 0x0D4A, 0x0DA5,
122 //* 1368 -1372 */ "0101 1100 1010", "1010 1101 0110", "1001 0101 0111", "0100 1010 1011", "1001 0100 1011",
123 0x05CA, 0x0AD6, 0x0957, 0x04AB, 0x094B,
124 //* 1373 -1377 */ "1010 1010 0101", "1011 0101 0010", "1011 0110 1010", "0101 0111 0101", "0010 0111 0110",
125 0x0AA5, 0x0B52, 0x0B6A, 0x0575, 0x0276,
126 //* 1378 -1382 */ "1000 1011 0111", "0100 0101 1011", "0101 0101 0101", "0101 1010 1001", "0101 1011 0100",
127 0x08B7, 0x045B, 0x0555, 0x05A9, 0x05B4,
128 //* 1383 -1387 */ "1001 1101 1010", "0100 1101 1101", "0010 0110 1110", "1001 0011 0110", "1010 1010 1010",
129 0x09DA, 0x04DD, 0x026E, 0x0936, 0x0AAA,
130 //* 1388 -1392 */ "1101 0101 0100", "1101 1011 0010", "0101 1101 0101", "0010 1101 1010", "1001 0101 1011",
131 0x0D54, 0x0DB2, 0x05D5, 0x02DA, 0x095B,
132 //* 1393 -1397 */ "0100 1010 1011", "1010 0101 0101", "1011 0100 1001", "1011 0110 0100", "1011 0111 0001",
133 0x04AB, 0x0A55, 0x0B49, 0x0B64, 0x0B71,
134 //* 1398 -1402 */ "0101 1011 0100", "1010 1011 0101", "1010 0101 0101", "1101 0010 0101", "1110 1001 0010",
135 0x05B4, 0x0AB5, 0x0A55, 0x0D25, 0x0E92,
136 //* 1403 -1407 */ "1110 1100 1001", "0110 1101 0100", "1010 1110 1001", "1001 0110 1011", "0100 1010 1011",
137 0x0EC9, 0x06D4, 0x0AE9, 0x096B, 0x04AB,
138 //* 1408 -1412 */ "1010 1001 0011", "1101 0100 1001", "1101 1010 0100", "1101 1011 0010", "1010 1011 1001",
139 0x0A93, 0x0D49, 0x0DA4, 0x0DB2, 0x0AB9,
140 //* 1413 -1417 */ "0100 1011 1010", "1010 0101 1011", "0101 0010 1011", "1010 1001 0101", "1011 0010 1010",
141 0x04BA, 0x0A5B, 0x052B, 0x0A95, 0x0B2A,
142 //* 1418 -1422 */ "1011 0101 0101", "0101 0101 1100", "0100 1011 1101", "0010 0011 1101", "1001 0001 1101",
143 0x0B55, 0x055C, 0x04BD, 0x023D, 0x091D,
144 //* 1423 -1427 */ "1010 1001 0101", "1011 0100 1010", "1011 0101 1010", "0101 0110 1101", "0010 1011 0110",
145 0x0A95, 0x0B4A, 0x0B5A, 0x056D, 0x02B6,
146 //* 1428 -1432 */ "1001 0011 1011", "0100 1001 1011", "0110 0101 0101", "0110 1010 1001", "0111 0101 0100",
147 0x093B, 0x049B, 0x0655, 0x06A9, 0x0754,
148 //* 1433 -1437 */ "1011 0110 1010", "0101 0110 1100", "1010 1010 1101", "0101 0101 0101", "1011 0010 1001",
149 0x0B6A, 0x056C, 0x0AAD, 0x0555, 0x0B29,
150 //* 1438 -1442 */ "1011 1001 0010", "1011 1010 1001", "0101 1101 0100", "1010 1101 1010", "0101 0101 1010",
151 0x0B92, 0x0BA9, 0x05D4, 0x0ADA, 0x055A,
152 //* 1443 -1447 */ "1010 1010 1011", "0101 1001 0101", "0111 0100 1001", "0111 0110 0100", "1011 1010 1010",
153 0x0AAB, 0x0595, 0x0749, 0x0764, 0x0BAA,
154 //* 1448 -1452 */ "0101 1011 0101", "0010 1011 0110", "1010 0101 0110", "1110 0100 1101", "1011 0010 0101",
155 0x05B5, 0x02B6, 0x0A56, 0x0E4D, 0x0B25,
156 //* 1453 -1457 */ "1011 0101 0010", "1011 0110 1010", "0101 1010 1101", "0010 1010 1110", "1001 0010 1111",
157 0x0B52, 0x0B6A, 0x05AD, 0x02AE, 0x092F,
158 //* 1458 -1462 */ "0100 1001 0111", "0110 0100 1011", "0110 1010 0101", "0110 1010 1100", "1010 1101 0110",
159 0x0497, 0x064B, 0x06A5, 0x06AC, 0x0AD6,
160 //* 1463 -1467 */ "0101 0101 1101", "0100 1001 1101", "1010 0100 1101", "1101 0001 0110", "1101 1001 0101",
161 0x055D, 0x049D, 0x0A4D, 0x0D16, 0x0D95,
162 //* 1468 -1472 */ "0101 1010 1010", "0101 1011 0101", "0010 1101 1010", "1001 0101 1011", "0100 1010 1101",
163 0x05AA, 0x05B5, 0x02DA, 0x095B, 0x04AD,
164 //* 1473 -1477 */ "0101 1001 0101", "0110 1100 1010", "0110 1110 0100", "1010 1110 1010", "0100 1111 0101",
165 0x0595, 0x06CA, 0x06E4, 0x0AEA, 0x04F5,
166 //* 1478 -1482 */ "0010 1011 0110", "1001 0101 0110", "1010 1010 1010", "1011 0101 0100", "1011 1101 0010",
167 0x02B6, 0x0956, 0x0AAA, 0x0B54, 0x0BD2,
168 //* 1483 -1487 */ "0101 1101 1001", "0010 1110 1010", "1001 0110 1101", "0100 1010 1101", "1010 1001 0101",
169 0x05D9, 0x02EA, 0x096D, 0x04AD, 0x0A95,
170 //* 1488 -1492 */ "1011 0100 1010", "1011 1010 0101", "0101 1011 0010", "1001 1011 0101", "0100 1101 0110",
171 0x0B4A, 0x0BA5, 0x05B2, 0x09B5, 0x04D6,
172 //* 1493 -1497 */ "1010 1001 0111", "0101 0100 0111", "0110 1001 0011", "0111 0100 1001", "1011 0101 0101",
173 0x0A97, 0x0547, 0x0693, 0x0749, 0x0B55,
174 //* 1498 -1508 */ "0101 0110 1010", "1010 0110 1011", "0101 0010 1011", "1010 1000 1011", "1101 0100 0110", "1101 1010 0011", "0101 1100 1010", "1010 1101 0110", "0100 1101 1011", "0010 0110 1011", "1001 0100 1011",
175 0x056A, 0x0A6B, 0x052B, 0x0A8B, 0x0D46, 0x0DA3, 0x05CA, 0x0AD6, 0x04DB, 0x026B, 0x094B,
176 //* 1509 -1519 */ "1010 1010 0101", "1011 0101 0010", "1011 0110 1001", "0101 0111 0101", "0001 0111 0110", "1000 1011 0111", "0010 0101 1011", "0101 0010 1011", "0101 0110 0101", "0101 1011 0100", "1001 1101 1010",
177 0x0AA5, 0x0B52, 0x0B69, 0x0575, 0x0176, 0x08B7, 0x025B, 0x052B, 0x0565, 0x05B4, 0x09DA,
178 //* 1520 -1530 */ "0100 1110 1101", "0001 0110 1101", "1000 1011 0110", "1010 1010 0110", "1101 0101 0010", "1101 1010 1001", "0101 1101 0100", "1010 1101 1010", "1001 0101 1011", "0100 1010 1011", "0110 0101 0011",
179 0x04ED, 0x016D, 0x08B6, 0x0AA6, 0x0D52, 0x0DA9, 0x05D4, 0x0ADA, 0x095B, 0x04AB, 0x0653,
180 //* 1531 -1541 */ "0111 0010 1001", "0111 0110 0010", "1011 1010 1001", "0101 1011 0010", "1010 1011 0101", "0101 0101 0101", "1011 0010 0101", "1101 1001 0010", "1110 1100 1001", "0110 1101 0010", "1010 1110 1001",
181 0x0729, 0x0762, 0x0BA9, 0x05B2, 0x0AB5, 0x0555, 0x0B25, 0x0D92, 0x0EC9, 0x06D2, 0x0AE9,
182 //* 1542 -1552 */ "0101 0110 1011", "0100 1010 1011", "1010 0101 0101", "1101 0010 1001", "1101 0101 0100", "1101 1010 1010", "1001 1011 0101", "0100 1011 1010", "1010 0011 1011", "0100 1001 1011", "1010 0100 1101",
183 0x056B, 0x04AB, 0x0A55, 0x0D29, 0x0D54, 0x0DAA, 0x09B5, 0x04BA, 0x0A3B, 0x049B, 0x0A4D,
184 //* 1553 -1563 */ "1010 1010 1010", "1010 1101 0101", "0010 1101 1010", "1001 0101 1101", "0100 0101 1110", "1010 0010 1110", "1100 1001 1010", "1101 0101 0101", "0110 1011 0010", "0110 1011 1001", "0100 1011 1010",
185 0x0AAA, 0x0AD5, 0x02DA, 0x095D, 0x045E, 0x0A2E, 0x0C9A, 0x0D55, 0x06B2, 0x06B9, 0x04BA,
186 //* 1564 -1574 */ "1010 0101 1101", "0101 0010 1101", "1010 1001 0101", "1011 0101 0010", "1011 1010 1000", "1011 1011 0100", "0101 1011 1001", "0010 1101 1010", "1001 0101 1010", "1011 0100 1010", "1101 1010 0100",
187 0x0A5D, 0x052D, 0x0A95, 0x0B52, 0x0BA8, 0x0BB4, 0x05B9, 0x02DA, 0x095A, 0x0B4A, 0x0DA4,
188 //* 1575 -1585 */ "1110 1101 0001", "0110 1110 1000", "1011 0110 1010", "0101 0110 1101", "0101 0011 0101", "0110 1001 0101", "1101 0100 1010", "1101 1010 1000", "1101 1101 0100", "0110 1101 1010", "0101 0101 1011",
189 0x0ED1, 0x06E8, 0x0B6A, 0x056D, 0x0535, 0x0695, 0x0D4A, 0x0DA8, 0x0DD4, 0x06DA, 0x055B,
190 //* 1586 -1596 */ "0010 1001 1101", "0110 0010 1011", "1011 0001 0101", "1011 0100 1010", "1011 1001 0101", "0101 1010 1010", "1010 1010 1110", "1001 0010 1110", "1100 1000 1111", "0101 0010 0111", "0110 1001 0101",
191 0x029D, 0x062B, 0x0B15, 0x0B4A, 0x0B95, 0x05AA, 0x0AAE, 0x092E, 0x0C8F, 0x0527, 0x0695,
192 //* 1597 -1600 */ "0110 1010 1010", "1010 1101 0110", "0101 0101 1101", "0010 1001 1101", };
193 0x06AA, 0x0AD6, 0x055D, 0x029D
194 };
195
getUmalqura_MonthLength(int32_t y,int32_t m)196 int32_t getUmalqura_MonthLength(int32_t y, int32_t m) {
197 int32_t mask = (int32_t) (0x01 << (11 - m)); // set mask for bit corresponding to month
198 if((UMALQURA_MONTHLENGTH[y] & mask) == 0 )
199 return 29;
200 else
201 return 30;
202
203 }
204
205 //-------------------------------------------------------------------------
206 // Constructors...
207 //-------------------------------------------------------------------------
208
getType() const209 const char *IslamicCalendar::getType() const {
210 const char *sType = NULL;
211
212 switch (cType) {
213 case CIVIL:
214 sType = "islamic-civil";
215 break;
216 case ASTRONOMICAL:
217 sType = "islamic";
218 break;
219 case TBLA:
220 sType = "islamic-tbla";
221 break;
222 case UMALQURA:
223 sType = "islamic-umalqura";
224 break;
225 default:
226 U_ASSERT(false); // out of range
227 sType = "islamic"; // "islamic" is used as the generic type
228 break;
229 }
230 return sType;
231 }
232
clone() const233 Calendar* IslamicCalendar::clone() const {
234 return new IslamicCalendar(*this);
235 }
236
IslamicCalendar(const Locale & aLocale,UErrorCode & success,ECalculationType type)237 IslamicCalendar::IslamicCalendar(const Locale& aLocale, UErrorCode& success, ECalculationType type)
238 : Calendar(TimeZone::createDefault(), aLocale, success),
239 cType(type)
240 {
241 setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
242 }
243
IslamicCalendar(const IslamicCalendar & other)244 IslamicCalendar::IslamicCalendar(const IslamicCalendar& other) : Calendar(other), cType(other.cType) {
245 }
246
~IslamicCalendar()247 IslamicCalendar::~IslamicCalendar()
248 {
249 }
250
setCalculationType(ECalculationType type,UErrorCode & status)251 void IslamicCalendar::setCalculationType(ECalculationType type, UErrorCode &status)
252 {
253 if (cType != type) {
254 // The fields of the calendar will become invalid, because the calendar
255 // rules are different
256 UDate m = getTimeInMillis(status);
257 cType = type;
258 clear();
259 setTimeInMillis(m, status);
260 }
261 }
262
263 /**
264 * Returns <code>true</code> if this object is using the fixed-cycle civil
265 * calendar, or <code>false</code> if using the religious, astronomical
266 * calendar.
267 * @draft ICU 2.4
268 */
isCivil()269 UBool IslamicCalendar::isCivil() {
270 return (cType == CIVIL);
271 }
272
273 //-------------------------------------------------------------------------
274 // Minimum / Maximum access functions
275 //-------------------------------------------------------------------------
276
277 // Note: Current IslamicCalendar implementation does not work
278 // well with negative years.
279
280 // TODO: In some cases the current ICU Islamic calendar implementation shows
281 // a month as having 31 days. Since date parsing now uses range checks based
282 // on the table below, we need to change the range for last day of month to
283 // include 31 as a workaround until the implementation is fixed.
284 static const int32_t LIMITS[UCAL_FIELD_COUNT][4] = {
285 // Minimum Greatest Least Maximum
286 // Minimum Maximum
287 { 0, 0, 0, 0}, // ERA
288 { 1, 1, 5000000, 5000000}, // YEAR
289 { 0, 0, 11, 11}, // MONTH
290 { 1, 1, 50, 51}, // WEEK_OF_YEAR
291 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // WEEK_OF_MONTH
292 { 1, 1, 29, 31}, // DAY_OF_MONTH - 31 to workaround for cal implementation bug, should be 30
293 { 1, 1, 354, 355}, // DAY_OF_YEAR
294 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DAY_OF_WEEK
295 { -1, -1, 5, 5}, // DAY_OF_WEEK_IN_MONTH
296 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // AM_PM
297 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR
298 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // HOUR_OF_DAY
299 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MINUTE
300 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // SECOND
301 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECOND
302 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // ZONE_OFFSET
303 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DST_OFFSET
304 { 1, 1, 5000000, 5000000}, // YEAR_WOY
305 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // DOW_LOCAL
306 { 1, 1, 5000000, 5000000}, // EXTENDED_YEAR
307 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // JULIAN_DAY
308 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // MILLISECONDS_IN_DAY
309 {/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1}, // IS_LEAP_MONTH
310 };
311
312 /**
313 * @draft ICU 2.4
314 */
handleGetLimit(UCalendarDateFields field,ELimitType limitType) const315 int32_t IslamicCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const {
316 return LIMITS[field][limitType];
317 }
318
319 //-------------------------------------------------------------------------
320 // Assorted calculation utilities
321 //
322
323 // we could compress this down more if we need to
324 static const int8_t umAlQuraYrStartEstimateFix[] = {
325 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, // 1300..
326 -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, // 1310..
327 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, // 1320..
328 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, // 1330..
329 0, 0, 1, 0, 0, -1, -1, 0, 0, 0, // 1340..
330 1, 0, 0, -1, 0, 0, 0, 1, 1, 0, // 1350..
331 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, // 1360..
332 0, 1, 1, 0, 0, -1, 0, 1, 0, 1, // 1370..
333 1, 0, 0, -1, 0, 1, 0, 0, 0, -1, // 1380..
334 0, 1, 0, 1, 0, 0, 0, -1, 0, 0, // 1390..
335 0, 0, -1, -1, 0, -1, 0, 1, 0, 0, // 1400..
336 0, -1, 0, 0, 0, 1, 0, 0, 0, 0, // 1410..
337 0, 1, 0, 0, -1, -1, 0, 0, 0, 1, // 1420..
338 0, 0, -1, -1, 0, -1, 0, 0, -1, -1, // 1430..
339 0, -1, 0, -1, 0, 0, -1, -1, 0, 0, // 1440..
340 0, 0, 0, 0, -1, 0, 1, 0, 1, 1, // 1450..
341 0, 0, -1, 0, 1, 0, 0, 0, 0, 0, // 1460..
342 1, 0, 1, 0, 0, 0, -1, 0, 1, 0, // 1470..
343 0, -1, -1, 0, 0, 0, 1, 0, 0, 0, // 1480..
344 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, // 1490..
345 1, 0, 0, -1, 0, 0, 0, 1, 1, 0, // 1500..
346 0, -1, 0, 1, 0, 1, 1, 0, 0, 0, // 1510..
347 0, 1, 0, 0, 0, -1, 0, 0, 0, 1, // 1520..
348 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, // 1530..
349 0, -1, 0, 1, 0, 0, 0, -1, 0, 1, // 1540..
350 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, // 1550..
351 -1, 0, 0, 0, 0, 1, 0, 0, 0, -1, // 1560..
352 0, 0, 0, 0, -1, -1, 0, -1, 0, 1, // 1570..
353 0, 0, -1, -1, 0, 0, 1, 1, 0, 0, // 1580..
354 -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, // 1590..
355 1 // 1600
356 };
357
358 /**
359 * Determine whether a year is a leap year in the Islamic civil calendar
360 */
civilLeapYear(int32_t year)361 UBool IslamicCalendar::civilLeapYear(int32_t year)
362 {
363 return (14 + 11 * year) % 30 < 11;
364 }
365
366 /**
367 * Return the day # on which the given year starts. Days are counted
368 * from the Hijri epoch, origin 0.
369 */
yearStart(int32_t year) const370 int32_t IslamicCalendar::yearStart(int32_t year) const{
371 if (cType == CIVIL || cType == TBLA ||
372 (cType == UMALQURA && (year < UMALQURA_YEAR_START || year > UMALQURA_YEAR_END)))
373 {
374 return (year-1)*354 + ClockMath::floorDivide((3+11*year),30);
375 } else if(cType==ASTRONOMICAL){
376 return trueMonthStart(12*(year-1));
377 } else {
378 year -= UMALQURA_YEAR_START;
379 // rounded least-squares fit of the dates previously calculated from UMALQURA_MONTHLENGTH iteration
380 int32_t yrStartLinearEstimate = (int32_t)((354.36720 * (double)year) + 460322.05 + 0.5);
381 // need a slight correction to some
382 return yrStartLinearEstimate + umAlQuraYrStartEstimateFix[year];
383 }
384 }
385
386 /**
387 * Return the day # on which the given month starts. Days are counted
388 * from the Hijri epoch, origin 0.
389 *
390 * @param year The hijri year
391 * @param month The hijri month, 0-based (assumed to be in range 0..11)
392 */
monthStart(int32_t year,int32_t month) const393 int32_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {
394 if (cType == CIVIL || cType == TBLA) {
395 // This does not handle months out of the range 0..11
396 return (int32_t)uprv_ceil(29.5*month)
397 + (year-1)*354 + (int32_t)ClockMath::floorDivide((3+11*year),30);
398 } else if(cType==ASTRONOMICAL){
399 return trueMonthStart(12*(year-1) + month);
400 } else {
401 int32_t ms = yearStart(year);
402 for(int i=0; i< month; i++){
403 ms+= handleGetMonthLength(year, i);
404 }
405 return ms;
406 }
407 }
408
409 /**
410 * Find the day number on which a particular month of the true/lunar
411 * Islamic calendar starts.
412 *
413 * @param month The month in question, origin 0 from the Hijri epoch
414 *
415 * @return The day number on which the given month starts.
416 */
trueMonthStart(int32_t month) const417 int32_t IslamicCalendar::trueMonthStart(int32_t month) const
418 {
419 UErrorCode status = U_ZERO_ERROR;
420 int32_t start = CalendarCache::get(&gMonthCache, month, status);
421
422 if (start==0) {
423 // Make a guess at when the month started, using the average length
424 UDate origin = HIJRA_MILLIS
425 + uprv_floor(month * CalendarAstronomer::SYNODIC_MONTH) * kOneDay;
426
427 // moonAge will fail due to memory allocation error
428 double age = moonAge(origin, status);
429 if (U_FAILURE(status)) {
430 goto trueMonthStartEnd;
431 }
432
433 if (age >= 0) {
434 // The month has already started
435 do {
436 origin -= kOneDay;
437 age = moonAge(origin, status);
438 if (U_FAILURE(status)) {
439 goto trueMonthStartEnd;
440 }
441 } while (age >= 0);
442 }
443 else {
444 // Preceding month has not ended yet.
445 do {
446 origin += kOneDay;
447 age = moonAge(origin, status);
448 if (U_FAILURE(status)) {
449 goto trueMonthStartEnd;
450 }
451 } while (age < 0);
452 }
453 start = (int32_t)ClockMath::floorDivide((origin - HIJRA_MILLIS), (double)kOneDay) + 1;
454 CalendarCache::put(&gMonthCache, month, start, status);
455 }
456 trueMonthStartEnd :
457 if(U_FAILURE(status)) {
458 start = 0;
459 }
460 return start;
461 }
462
463 /**
464 * Return the "age" of the moon at the given time; this is the difference
465 * in ecliptic latitude between the moon and the sun. This method simply
466 * calls CalendarAstronomer.moonAge, converts to degrees,
467 * and adjusts the result to be in the range [-180, 180].
468 *
469 * @param time The time at which the moon's age is desired,
470 * in millis since 1/1/1970.
471 */
moonAge(UDate time,UErrorCode & status)472 double IslamicCalendar::moonAge(UDate time, UErrorCode &status)
473 {
474 double age = 0;
475
476 umtx_lock(&astroLock);
477 if(gIslamicCalendarAstro == NULL) {
478 gIslamicCalendarAstro = new CalendarAstronomer();
479 if (gIslamicCalendarAstro == NULL) {
480 status = U_MEMORY_ALLOCATION_ERROR;
481 return age;
482 }
483 ucln_i18n_registerCleanup(UCLN_I18N_ISLAMIC_CALENDAR, calendar_islamic_cleanup);
484 }
485 gIslamicCalendarAstro->setTime(time);
486 age = gIslamicCalendarAstro->getMoonAge();
487 umtx_unlock(&astroLock);
488
489 // Convert to degrees and normalize...
490 age = age * 180 / CalendarAstronomer::PI;
491 if (age > 180) {
492 age = age - 360;
493 }
494
495 return age;
496 }
497
498 //----------------------------------------------------------------------
499 // Calendar framework
500 //----------------------------------------------------------------------
501
502 /**
503 * Return the length (in days) of the given month.
504 *
505 * @param year The hijri year
506 * @param year The hijri month, 0-based
507 * @draft ICU 2.4
508 */
handleGetMonthLength(int32_t extendedYear,int32_t month) const509 int32_t IslamicCalendar::handleGetMonthLength(int32_t extendedYear, int32_t month) const {
510
511 int32_t length = 0;
512
513 if (cType == CIVIL || cType == TBLA ||
514 (cType == UMALQURA && (extendedYear<UMALQURA_YEAR_START || extendedYear>UMALQURA_YEAR_END)) ) {
515 length = 29 + (month+1) % 2;
516 if (month == DHU_AL_HIJJAH && civilLeapYear(extendedYear)) {
517 length++;
518 }
519 } else if(cType == ASTRONOMICAL){
520 month = 12*(extendedYear-1) + month;
521 length = trueMonthStart(month+1) - trueMonthStart(month) ;
522 } else {
523 length = getUmalqura_MonthLength(extendedYear - UMALQURA_YEAR_START, month);
524 }
525 return length;
526 }
527
528 /**
529 * Return the number of days in the given Islamic year
530 * @draft ICU 2.4
531 */
handleGetYearLength(int32_t extendedYear) const532 int32_t IslamicCalendar::handleGetYearLength(int32_t extendedYear) const {
533 if (cType == CIVIL || cType == TBLA ||
534 (cType == UMALQURA && (extendedYear<UMALQURA_YEAR_START || extendedYear>UMALQURA_YEAR_END)) ) {
535 return 354 + (civilLeapYear(extendedYear) ? 1 : 0);
536 } else if(cType == ASTRONOMICAL){
537 int32_t month = 12*(extendedYear-1);
538 return (trueMonthStart(month + 12) - trueMonthStart(month));
539 } else {
540 int len = 0;
541 for(int i=0; i<12; i++) {
542 len += handleGetMonthLength(extendedYear, i);
543 }
544 return len;
545 }
546 }
547
548 //-------------------------------------------------------------------------
549 // Functions for converting from field values to milliseconds....
550 //-------------------------------------------------------------------------
551
552 // Return JD of start of given month/year
553 // Calendar says:
554 // Get the Julian day of the day BEFORE the start of this year.
555 // If useMonth is true, get the day before the start of the month.
556 // Hence the -1
557 /**
558 * @draft ICU 2.4
559 */
handleComputeMonthStart(int32_t eyear,int32_t month,UBool) const560 int32_t IslamicCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */) const {
561 // This may be called by Calendar::handleComputeJulianDay with months out of the range
562 // 0..11. Need to handle that here since monthStart requires months in the range 0.11.
563 if (month > 11) {
564 eyear += (month / 12);
565 month %= 12;
566 } else if (month < 0) {
567 month++;
568 eyear += (month / 12) - 1;
569 month = (month % 12) + 11;
570 }
571 return monthStart(eyear, month) + ((cType == TBLA)? ASTRONOMICAL_EPOC: CIVIL_EPOC) - 1;
572 }
573
574 //-------------------------------------------------------------------------
575 // Functions for converting from milliseconds to field values
576 //-------------------------------------------------------------------------
577
578 /**
579 * @draft ICU 2.4
580 */
handleGetExtendedYear()581 int32_t IslamicCalendar::handleGetExtendedYear() {
582 int32_t year;
583 if (newerField(UCAL_EXTENDED_YEAR, UCAL_YEAR) == UCAL_EXTENDED_YEAR) {
584 year = internalGet(UCAL_EXTENDED_YEAR, 1); // Default to year 1
585 } else {
586 year = internalGet(UCAL_YEAR, 1); // Default to year 1
587 }
588 return year;
589 }
590
591 /**
592 * Override Calendar to compute several fields specific to the Islamic
593 * calendar system. These are:
594 *
595 * <ul><li>ERA
596 * <li>YEAR
597 * <li>MONTH
598 * <li>DAY_OF_MONTH
599 * <li>DAY_OF_YEAR
600 * <li>EXTENDED_YEAR</ul>
601 *
602 * The DAY_OF_WEEK and DOW_LOCAL fields are already set when this
603 * method is called. The getGregorianXxx() methods return Gregorian
604 * calendar equivalents for the given Julian day.
605 * @draft ICU 2.4
606 */
handleComputeFields(int32_t julianDay,UErrorCode & status)607 void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
608 int32_t year, month, dayOfMonth, dayOfYear;
609 int32_t startDate;
610 int32_t days = julianDay - CIVIL_EPOC;
611
612 if (cType == CIVIL || cType == TBLA) {
613 if(cType == TBLA) {
614 days = julianDay - ASTRONOMICAL_EPOC;
615 }
616 // Use the civil calendar approximation, which is just arithmetic
617 year = (int32_t)ClockMath::floorDivide(30 * (int64_t)days + 10646, (int64_t)10631);
618 month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
619 month = month<11?month:11;
620 startDate = monthStart(year, month);
621 } else if(cType == ASTRONOMICAL){
622 // Guess at the number of elapsed full months since the epoch
623 int32_t months = (int32_t)uprv_floor((double)days / CalendarAstronomer::SYNODIC_MONTH);
624
625 startDate = (int32_t)uprv_floor(months * CalendarAstronomer::SYNODIC_MONTH);
626
627 double age = moonAge(internalGetTime(), status);
628 if (U_FAILURE(status)) {
629 status = U_MEMORY_ALLOCATION_ERROR;
630 return;
631 }
632 if ( days - startDate >= 25 && age > 0) {
633 // If we're near the end of the month, assume next month and search backwards
634 months++;
635 }
636
637 // Find out the last time that the new moon was actually visible at this longitude
638 // This returns midnight the night that the moon was visible at sunset.
639 while ((startDate = trueMonthStart(months)) > days) {
640 // If it was after the date in question, back up a month and try again
641 months--;
642 }
643
644 year = months / 12 + 1;
645 month = months % 12;
646 } else if(cType == UMALQURA) {
647 int32_t umalquraStartdays = yearStart(UMALQURA_YEAR_START) ;
648 if( days < umalquraStartdays){
649 //Use Civil calculation
650 year = (int)ClockMath::floorDivide( (double)(30 * days + 10646) , 10631.0 );
651 month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
652 month = month<11?month:11;
653 startDate = monthStart(year, month);
654 }else{
655 int y =UMALQURA_YEAR_START-1, m =0;
656 long d = 1;
657 while(d > 0){
658 y++;
659 d = days - yearStart(y) +1;
660 if(d == handleGetYearLength(y)){
661 m=11;
662 break;
663 }else if(d < handleGetYearLength(y) ){
664 int monthLen = handleGetMonthLength(y, m);
665 m=0;
666 while(d > monthLen){
667 d -= monthLen;
668 m++;
669 monthLen = handleGetMonthLength(y, m);
670 }
671 break;
672 }
673 }
674 year = y;
675 month = m;
676 }
677 } else { // invalid 'civil'
678 U_ASSERT(false); // should not get here, out of range
679 year=month=0;
680 }
681
682 dayOfMonth = (days - monthStart(year, month)) + 1;
683
684 // Now figure out the day of the year.
685 dayOfYear = (days - monthStart(year, 0)) + 1;
686
687
688 internalSet(UCAL_ERA, 0);
689 internalSet(UCAL_YEAR, year);
690 internalSet(UCAL_EXTENDED_YEAR, year);
691 internalSet(UCAL_MONTH, month);
692 internalSet(UCAL_DAY_OF_MONTH, dayOfMonth);
693 internalSet(UCAL_DAY_OF_YEAR, dayOfYear);
694 }
695
696 UBool
inDaylightTime(UErrorCode & status) const697 IslamicCalendar::inDaylightTime(UErrorCode& status) const
698 {
699 // copied from GregorianCalendar
700 if (U_FAILURE(status) || !getTimeZone().useDaylightTime())
701 return FALSE;
702
703 // Force an update of the state of the Calendar.
704 ((IslamicCalendar*)this)->complete(status); // cast away const
705
706 return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE);
707 }
708
709 /**
710 * The system maintains a static default century start date and Year. They are
711 * initialized the first time they are used. Once the system default century date
712 * and year are set, they do not change.
713 */
714 static UDate gSystemDefaultCenturyStart = DBL_MIN;
715 static int32_t gSystemDefaultCenturyStartYear = -1;
716 static icu::UInitOnce gSystemDefaultCenturyInit = U_INITONCE_INITIALIZER;
717
718
haveDefaultCentury() const719 UBool IslamicCalendar::haveDefaultCentury() const
720 {
721 return TRUE;
722 }
723
defaultCenturyStart() const724 UDate IslamicCalendar::defaultCenturyStart() const
725 {
726 // lazy-evaluate systemDefaultCenturyStart
727 umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
728 return gSystemDefaultCenturyStart;
729 }
730
defaultCenturyStartYear() const731 int32_t IslamicCalendar::defaultCenturyStartYear() const
732 {
733 // lazy-evaluate systemDefaultCenturyStartYear
734 umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
735 return gSystemDefaultCenturyStartYear;
736 }
737
738
739 U_CFUNC void U_CALLCONV
initializeSystemDefaultCentury()740 IslamicCalendar::initializeSystemDefaultCentury()
741 {
742 // initialize systemDefaultCentury and systemDefaultCenturyYear based
743 // on the current time. They'll be set to 80 years before
744 // the current time.
745 UErrorCode status = U_ZERO_ERROR;
746 IslamicCalendar calendar(Locale("@calendar=islamic-civil"),status);
747 if (U_SUCCESS(status)) {
748 calendar.setTime(Calendar::getNow(), status);
749 calendar.add(UCAL_YEAR, -80, status);
750
751 gSystemDefaultCenturyStart = calendar.getTime(status);
752 gSystemDefaultCenturyStartYear = calendar.get(UCAL_YEAR, status);
753 }
754 // We have no recourse upon failure unless we want to propagate the failure
755 // out.
756 }
757
758
759
760 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IslamicCalendar)
761
762 U_NAMESPACE_END
763
764 #endif
765
766