• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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