]> git.saurik.com Git - apple/icu.git/blob - icuSources/i18n/islamcal.cpp
projects / apple / icu.git / blob
? search:


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