ICU-64260.0.1.tar.gz

[apple/icu.git] / icuSources / i18n / islamcal.cpp

diff --git a/icuSources/i18n/islamcal.cpp b/icuSources/i18n/islamcal.cpp
index 968c88ab661044e00816b1638d5e4189801b982d..b44b60c3db3b01e41cbb846a9e700d76e1f7aac0 100644 (file)
--- a/icuSources/i18n/islamcal.cpp
+++ b/icuSources/i18n/islamcal.cpp
@@ -1,6 +1,8 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /*
 ******************************************************************************
 /*
 ******************************************************************************

-* Copyright (C) 2003-2011, International Business Machines Corporation
+* Copyright (C) 2003-2015, International Business Machines Corporation

 * and others. All Rights Reserved.
 ******************************************************************************
 *
 * and others. All Rights Reserved.
 ******************************************************************************
 *


@@ -23,6 +25,7 @@
 #include "astro.h" // CalendarAstronomer
 #include "uhash.h"
 #include "ucln_in.h"
 #include "astro.h" // CalendarAstronomer
 #include "uhash.h"
 #include "ucln_in.h"

+#include "uassert.h"

 
 static const UDate HIJRA_MILLIS = -42521587200000.0;    // 7/16/622 AD 00:00
 
 
 static const UDate HIJRA_MILLIS = -42521587200000.0;    // 7/16/622 AD 00:00
 


@@ -51,7 +54,6 @@ static void debug_islamcal_msg(const char *pat, ...)
 
 // --- The cache --
 // cache of months
 
 // --- The cache --
 // cache of months

-static UMTX astroLock = 0;  // pod bay door lock

 static icu::CalendarCache *gMonthCache = NULL;
 static icu::CalendarAstronomer *gIslamicCalendarAstro = NULL;
 
 static icu::CalendarCache *gMonthCache = NULL;
 static icu::CalendarAstronomer *gIslamicCalendarAstro = NULL;
 


@@ -65,7 +67,6 @@ static UBool calendar_islamic_cleanup(void) {
         delete gIslamicCalendarAstro;
         gIslamicCalendarAstro = NULL;
     }
         delete gIslamicCalendarAstro;
         gIslamicCalendarAstro = NULL;
     }

-    umtx_destroy(&astroLock);

     return TRUE;
 }
 U_CDECL_END
     return TRUE;
 }
 U_CDECL_END


@@ -74,51 +75,183 @@ U_NAMESPACE_BEGIN
 
 // Implementation of the IslamicCalendar class
 
 
 // Implementation of the IslamicCalendar class
 

+/**
+ * Friday EPOC
+ */
+static const int32_t CIVIL_EPOC = 1948440; // CE 622 July 16 Friday (Julian calendar) / CE 622 July 19 (Gregorian calendar)
+
+/**
+  * Thursday EPOC
+  */
+static const int32_t ASTRONOMICAL_EPOC = 1948439; // CE 622 July 15 Thursday (Julian calendar)
+
+
+static const int32_t UMALQURA_YEAR_START = 1300;
+static const int32_t UMALQURA_YEAR_END = 1600;
+
+static const int UMALQURA_MONTHLENGTH[] = {
+    //* 1300 -1302 */ "1010 1010 1010", "1101 0101 0100", "1110 1100 1001",
+                            0x0AAA,           0x0D54,           0x0EC9,
+    //* 1303 -1307 */ "0110 1101 0100", "0110 1110 1010", "0011 0110 1100", "1010 1010 1101", "0101 0101 0101",
+                            0x06D4,           0x06EA,           0x036C,           0x0AAD,           0x0555,
+    //* 1308 -1312 */ "0110 1010 1001", "0111 1001 0010", "1011 1010 1001", "0101 1101 0100", "1010 1101 1010",
+                            0x06A9,           0x0792,           0x0BA9,           0x05D4,           0x0ADA,
+    //* 1313 -1317 */ "0101 0101 1100", "1101 0010 1101", "0110 1001 0101", "0111 0100 1010", "1011 0101 0100",
+                            0x055C,           0x0D2D,           0x0695,           0x074A,           0x0B54,
+    //* 1318 -1322 */ "1011 0110 1010", "0101 1010 1101", "0100 1010 1110", "1010 0100 1111", "0101 0001 0111",
+                            0x0B6A,           0x05AD,           0x04AE,           0x0A4F,           0x0517,
+    //* 1323 -1327 */ "0110 1000 1011", "0110 1010 0101", "1010 1101 0101", "0010 1101 0110", "1001 0101 1011",
+                            0x068B,           0x06A5,           0x0AD5,           0x02D6,           0x095B,
+    //* 1328 -1332 */ "0100 1001 1101", "1010 0100 1101", "1101 0010 0110", "1101 1001 0101", "0101 1010 1100",
+                            0x049D,           0x0A4D,           0x0D26,           0x0D95,           0x05AC,
+    //* 1333 -1337 */ "1001 1011 0110", "0010 1011 1010", "1010 0101 1011", "0101 0010 1011", "1010 1001 0101",
+                            0x09B6,           0x02BA,           0x0A5B,           0x052B,           0x0A95,
+    //* 1338 -1342 */ "0110 1100 1010", "1010 1110 1001", "0010 1111 0100", "1001 0111 0110", "0010 1011 0110",
+                            0x06CA,           0x0AE9,           0x02F4,           0x0976,           0x02B6,
+    //* 1343 -1347 */ "1001 0101 0110", "1010 1100 1010", "1011 1010 0100", "1011 1101 0010", "0101 1101 1001",
+                            0x0956,           0x0ACA,           0x0BA4,           0x0BD2,           0x05D9,
+    //* 1348 -1352 */ "0010 1101 1100", "1001 0110 1101", "0101 0100 1101", "1010 1010 0101", "1011 0101 0010",
+                            0x02DC,           0x096D,           0x054D,           0x0AA5,           0x0B52,
+    //* 1353 -1357 */ "1011 1010 0101", "0101 1011 0100", "1001 1011 0110", "0101 0101 0111", "0010 1001 0111",
+                            0x0BA5,           0x05B4,           0x09B6,           0x0557,           0x0297,
+    //* 1358 -1362 */ "0101 0100 1011", "0110 1010 0011", "0111 0101 0010", "1011 0110 0101", "0101 0110 1010",
+                            0x054B,           0x06A3,           0x0752,           0x0B65,           0x056A,
+    //* 1363 -1367 */ "1010 1010 1011", "0101 0010 1011", "1100 1001 0101", "1101 0100 1010", "1101 1010 0101",
+                            0x0AAB,           0x052B,           0x0C95,           0x0D4A,           0x0DA5,
+    //* 1368 -1372 */ "0101 1100 1010", "1010 1101 0110", "1001 0101 0111", "0100 1010 1011", "1001 0100 1011",
+                            0x05CA,           0x0AD6,           0x0957,           0x04AB,           0x094B,
+    //* 1373 -1377 */ "1010 1010 0101", "1011 0101 0010", "1011 0110 1010", "0101 0111 0101", "0010 0111 0110",
+                            0x0AA5,           0x0B52,           0x0B6A,           0x0575,           0x0276,
+    //* 1378 -1382 */ "1000 1011 0111", "0100 0101 1011", "0101 0101 0101", "0101 1010 1001", "0101 1011 0100",
+                            0x08B7,           0x045B,           0x0555,           0x05A9,           0x05B4,
+    //* 1383 -1387 */ "1001 1101 1010", "0100 1101 1101", "0010 0110 1110", "1001 0011 0110", "1010 1010 1010",
+                            0x09DA,           0x04DD,           0x026E,           0x0936,           0x0AAA,
+    //* 1388 -1392 */ "1101 0101 0100", "1101 1011 0010", "0101 1101 0101", "0010 1101 1010", "1001 0101 1011",
+                            0x0D54,           0x0DB2,           0x05D5,           0x02DA,           0x095B,
+    //* 1393 -1397 */ "0100 1010 1011", "1010 0101 0101", "1011 0100 1001", "1011 0110 0100", "1011 0111 0001",
+                            0x04AB,           0x0A55,           0x0B49,           0x0B64,           0x0B71,
+    //* 1398 -1402 */ "0101 1011 0100", "1010 1011 0101", "1010 0101 0101", "1101 0010 0101", "1110 1001 0010",
+                            0x05B4,           0x0AB5,           0x0A55,           0x0D25,           0x0E92,
+    //* 1403 -1407 */ "1110 1100 1001", "0110 1101 0100", "1010 1110 1001", "1001 0110 1011", "0100 1010 1011",
+                            0x0EC9,           0x06D4,           0x0AE9,           0x096B,           0x04AB,
+    //* 1408 -1412 */ "1010 1001 0011", "1101 0100 1001", "1101 1010 0100", "1101 1011 0010", "1010 1011 1001",
+                            0x0A93,           0x0D49,         0x0DA4,           0x0DB2,           0x0AB9,
+    //* 1413 -1417 */ "0100 1011 1010", "1010 0101 1011", "0101 0010 1011", "1010 1001 0101", "1011 0010 1010",
+                            0x04BA,           0x0A5B,           0x052B,           0x0A95,           0x0B2A,
+    //* 1418 -1422 */ "1011 0101 0101", "0101 0101 1100", "0100 1011 1101", "0010 0011 1101", "1001 0001 1101",
+                            0x0B55,           0x055C,           0x04BD,           0x023D,           0x091D,
+    //* 1423 -1427 */ "1010 1001 0101", "1011 0100 1010", "1011 0101 1010", "0101 0110 1101", "0010 1011 0110",
+                            0x0A95,           0x0B4A,           0x0B5A,           0x056D,           0x02B6,
+    //* 1428 -1432 */ "1001 0011 1011", "0100 1001 1011", "0110 0101 0101", "0110 1010 1001", "0111 0101 0100",
+                            0x093B,           0x049B,           0x0655,           0x06A9,           0x0754,
+    //* 1433 -1437 */ "1011 0110 1010", "0101 0110 1100", "1010 1010 1101", "0101 0101 0101", "1011 0010 1001",
+                            0x0B6A,           0x056C,           0x0AAD,           0x0555,           0x0B29,
+    //* 1438 -1442 */ "1011 1001 0010", "1011 1010 1001", "0101 1101 0100", "1010 1101 1010", "0101 0101 1010",
+                            0x0B92,           0x0BA9,           0x05D4,           0x0ADA,           0x055A,
+    //* 1443 -1447 */ "1010 1010 1011", "0101 1001 0101", "0111 0100 1001", "0111 0110 0100", "1011 1010 1010",
+                            0x0AAB,           0x0595,           0x0749,           0x0764,           0x0BAA,
+    //* 1448 -1452 */ "0101 1011 0101", "0010 1011 0110", "1010 0101 0110", "1110 0100 1101", "1011 0010 0101",
+                            0x05B5,           0x02B6,           0x0A56,           0x0E4D,           0x0B25,
+    //* 1453 -1457 */ "1011 0101 0010", "1011 0110 1010", "0101 1010 1101", "0010 1010 1110", "1001 0010 1111",
+                            0x0B52,           0x0B6A,           0x05AD,           0x02AE,           0x092F,
+    //* 1458 -1462 */ "0100 1001 0111", "0110 0100 1011", "0110 1010 0101", "0110 1010 1100", "1010 1101 0110",
+                            0x0497,           0x064B,           0x06A5,           0x06AC,           0x0AD6,
+    //* 1463 -1467 */ "0101 0101 1101", "0100 1001 1101", "1010 0100 1101", "1101 0001 0110", "1101 1001 0101",
+                            0x055D,           0x049D,           0x0A4D,           0x0D16,           0x0D95,
+    //* 1468 -1472 */ "0101 1010 1010", "0101 1011 0101", "0010 1101 1010", "1001 0101 1011", "0100 1010 1101",
+                            0x05AA,           0x05B5,           0x02DA,           0x095B,           0x04AD,
+    //* 1473 -1477 */ "0101 1001 0101", "0110 1100 1010", "0110 1110 0100", "1010 1110 1010", "0100 1111 0101",
+                            0x0595,           0x06CA,           0x06E4,           0x0AEA,           0x04F5,
+    //* 1478 -1482 */ "0010 1011 0110", "1001 0101 0110", "1010 1010 1010", "1011 0101 0100", "1011 1101 0010",
+                            0x02B6,           0x0956,           0x0AAA,           0x0B54,           0x0BD2,
+    //* 1483 -1487 */ "0101 1101 1001", "0010 1110 1010", "1001 0110 1101", "0100 1010 1101", "1010 1001 0101",
+                            0x05D9,           0x02EA,           0x096D,           0x04AD,           0x0A95,
+    //* 1488 -1492 */ "1011 0100 1010", "1011 1010 0101", "0101 1011 0010", "1001 1011 0101", "0100 1101 0110",
+                            0x0B4A,           0x0BA5,           0x05B2,           0x09B5,           0x04D6,
+    //* 1493 -1497 */ "1010 1001 0111", "0101 0100 0111", "0110 1001 0011", "0111 0100 1001", "1011 0101 0101",
+                            0x0A97,           0x0547,           0x0693,           0x0749,           0x0B55,
+    //* 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",
+                            0x056A,           0x0A6B,           0x052B,           0x0A8B,           0x0D46,           0x0DA3,           0x05CA,           0x0AD6,           0x04DB,           0x026B,           0x094B,
+    //* 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",
+                            0x0AA5,           0x0B52,           0x0B69,           0x0575,           0x0176,           0x08B7,           0x025B,           0x052B,           0x0565,           0x05B4,           0x09DA,
+    //* 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",
+                            0x04ED,           0x016D,           0x08B6,           0x0AA6,           0x0D52,           0x0DA9,           0x05D4,           0x0ADA,           0x095B,           0x04AB,           0x0653,
+    //* 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",
+                            0x0729,           0x0762,           0x0BA9,           0x05B2,           0x0AB5,           0x0555,           0x0B25,           0x0D92,           0x0EC9,           0x06D2,           0x0AE9,
+    //* 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",
+                            0x056B,           0x04AB,           0x0A55,           0x0D29,           0x0D54,           0x0DAA,           0x09B5,           0x04BA,           0x0A3B,           0x049B,           0x0A4D,
+    //* 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",
+                            0x0AAA,           0x0AD5,           0x02DA,           0x095D,           0x045E,           0x0A2E,           0x0C9A,           0x0D55,           0x06B2,           0x06B9,           0x04BA,
+    //* 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",
+                            0x0A5D,           0x052D,           0x0A95,           0x0B52,           0x0BA8,           0x0BB4,           0x05B9,           0x02DA,           0x095A,           0x0B4A,           0x0DA4,
+    //* 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",
+                            0x0ED1,           0x06E8,           0x0B6A,           0x056D,           0x0535,           0x0695,           0x0D4A,           0x0DA8,           0x0DD4,           0x06DA,           0x055B,
+    //* 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",
+                            0x029D,           0x062B,           0x0B15,           0x0B4A,           0x0B95,           0x05AA,           0x0AAE,           0x092E,           0x0C8F,           0x0527,           0x0695,
+    //* 1597 -1600 */ "0110 1010 1010", "1010 1101 0110", "0101 0101 1101", "0010 1001 1101", };
+                            0x06AA,           0x0AD6,           0x055D,           0x029D
+};
+
+int32_t getUmalqura_MonthLength(int32_t y, int32_t m) {
+    int32_t mask = (int32_t) (0x01 << (11 - m));    // set mask for bit corresponding to month
+    if((UMALQURA_MONTHLENGTH[y] & mask) == 0 )
+        return 29;
+    else
+        return 30;
+
+}
+

 //-------------------------------------------------------------------------
 // Constructors...
 //-------------------------------------------------------------------------
 
 //-------------------------------------------------------------------------
 // Constructors...
 //-------------------------------------------------------------------------
 

-const char *IslamicCalendar::getType() const { 
-    if(civil==CIVIL) {
-        return "islamic-civil";
-    } else {
-        return "islamic";
+const char *IslamicCalendar::getType() const {
+    const char *sType = NULL;
+
+    switch (cType) {
+    case CIVIL:
+        sType = "islamic-civil";
+        break;
+    case ASTRONOMICAL:
+        sType = "islamic";
+        break;
+    case TBLA:
+        sType = "islamic-tbla";
+        break;
+    case UMALQURA:
+        sType = "islamic-umalqura";
+        break;
+    default:
+        UPRV_UNREACHABLE; // out of range

     }
     }

+    return sType;

 }
 
 Calendar* IslamicCalendar::clone() const {
     return new IslamicCalendar(*this);
 }
 
 }
 
 Calendar* IslamicCalendar::clone() const {
     return new IslamicCalendar(*this);
 }
 

-IslamicCalendar::IslamicCalendar(const Locale& aLocale, UErrorCode& success, ECivil beCivil)
+IslamicCalendar::IslamicCalendar(const Locale& aLocale, UErrorCode& success, ECalculationType type)

 :   Calendar(TimeZone::createDefault(), aLocale, success),
 :   Calendar(TimeZone::createDefault(), aLocale, success),

-civil(beCivil)
+cType(type)

 {
     setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
 }
 
 {
     setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly.
 }
 

-IslamicCalendar::IslamicCalendar(const IslamicCalendar& other) : Calendar(other), civil(other.civil) {
+IslamicCalendar::IslamicCalendar(const IslamicCalendar& other) : Calendar(other), cType(other.cType) {

 }
 
 IslamicCalendar::~IslamicCalendar()
 {
 }
 
 }
 
 IslamicCalendar::~IslamicCalendar()
 {
 }
 

-/**
-* Determines whether this object uses the fixed-cycle Islamic civil calendar
-* or an approximation of the religious, astronomical calendar.
-*
-* @param beCivil   <code>true</code> to use the civil calendar,
-*                  <code>false</code> to use the astronomical calendar.
-* @draft ICU 2.4
-*/
-void IslamicCalendar::setCivil(ECivil beCivil, UErrorCode &status)
+void IslamicCalendar::setCalculationType(ECalculationType type, UErrorCode &status)

 {
 {

-    if (civil != beCivil) {
+    if (cType != type) {

         // The fields of the calendar will become invalid, because the calendar
         // rules are different
         UDate m = getTimeInMillis(status);
         // The fields of the calendar will become invalid, because the calendar
         // rules are different
         UDate m = getTimeInMillis(status);

-        civil = beCivil;
+        cType = type;

         clear();
         setTimeInMillis(m, status);
     }
         clear();
         setTimeInMillis(m, status);
     }


@@ -131,7 +264,7 @@ void IslamicCalendar::setCivil(ECivil beCivil, UErrorCode &status)
 * @draft ICU 2.4
 */
 UBool IslamicCalendar::isCivil() {
 * @draft ICU 2.4
 */
 UBool IslamicCalendar::isCivil() {

-    return (civil == CIVIL);
+    return (cType == CIVIL);

 }
 
 //-------------------------------------------------------------------------
 }
 
 //-------------------------------------------------------------------------


@@ -184,6 +317,41 @@ int32_t IslamicCalendar::handleGetLimit(UCalendarDateFields field, ELimitType li
 // Assorted calculation utilities
 //
 
 // Assorted calculation utilities
 //
 

+// we could compress this down more if we need to
+static const int8_t umAlQuraYrStartEstimateFix[] = {
+     0,  0, -1,  0, -1,  0,  0,  0,  0,  0, // 1300..
+    -1,  0,  0,  0,  0,  0,  0,  0, -1,  0, // 1310..
+     1,  0,  1,  1,  0,  0,  0,  0,  1,  0, // 1320..
+     0,  0,  0,  0,  0,  0,  1,  0,  0,  0, // 1330..
+     0,  0,  1,  0,  0, -1, -1,  0,  0,  0, // 1340..
+     1,  0,  0, -1,  0,  0,  0,  1,  1,  0, // 1350..
+     0,  0,  0,  0,  0,  0,  0, -1,  0,  0, // 1360..
+     0,  1,  1,  0,  0, -1,  0,  1,  0,  1, // 1370..
+     1,  0,  0, -1,  0,  1,  0,  0,  0, -1, // 1380..
+     0,  1,  0,  1,  0,  0,  0, -1,  0,  0, // 1390..
+     0,  0, -1, -1,  0, -1,  0,  1,  0,  0, // 1400..
+     0, -1,  0,  0,  0,  1,  0,  0,  0,  0, // 1410..
+     0,  1,  0,  0, -1, -1,  0,  0,  0,  1, // 1420..
+     0,  0, -1, -1,  0, -1,  0,  0, -1, -1, // 1430..
+     0, -1,  0, -1,  0,  0, -1, -1,  0,  0, // 1440..
+     0,  0,  0,  0, -1,  0,  1,  0,  1,  1, // 1450..
+     0,  0, -1,  0,  1,  0,  0,  0,  0,  0, // 1460..
+     1,  0,  1,  0,  0,  0, -1,  0,  1,  0, // 1470..
+     0, -1, -1,  0,  0,  0,  1,  0,  0,  0, // 1480..
+     0,  0,  0,  0,  1,  0,  0,  0,  0,  0, // 1490..
+     1,  0,  0, -1,  0,  0,  0,  1,  1,  0, // 1500..
+     0, -1,  0,  1,  0,  1,  1,  0,  0,  0, // 1510..
+     0,  1,  0,  0,  0, -1,  0,  0,  0,  1, // 1520..
+     0,  0,  0, -1,  0,  0,  0,  0,  0, -1, // 1530..
+     0, -1,  0,  1,  0,  0,  0, -1,  0,  1, // 1540..
+     0,  1,  0,  0,  0,  0,  0,  1,  0,  0, // 1550..
+    -1,  0,  0,  0,  0,  1,  0,  0,  0, -1, // 1560..
+     0,  0,  0,  0, -1, -1,  0, -1,  0,  1, // 1570..
+     0,  0, -1, -1,  0,  0,  1,  1,  0,  0, // 1580..
+    -1,  0,  0,  0,  0,  1,  0,  0,  0,  0, // 1590..
+     1 // 1600
+};
+

 /**
 * Determine whether a year is a leap year in the Islamic civil calendar
 */
 /**
 * Determine whether a year is a leap year in the Islamic civil calendar
 */


@@ -196,11 +364,19 @@ UBool IslamicCalendar::civilLeapYear(int32_t year)
 * Return the day # on which the given year starts.  Days are counted
 * from the Hijri epoch, origin 0.
 */
 * Return the day # on which the given year starts.  Days are counted
 * from the Hijri epoch, origin 0.
 */

-int32_t IslamicCalendar::yearStart(int32_t year) {
-    if (civil == CIVIL) {
+int32_t IslamicCalendar::yearStart(int32_t year) const{
+    if (cType == CIVIL || cType == TBLA ||
+        (cType == UMALQURA && (year < UMALQURA_YEAR_START || year > UMALQURA_YEAR_END))) 
+    {

         return (year-1)*354 + ClockMath::floorDivide((3+11*year),30);
         return (year-1)*354 + ClockMath::floorDivide((3+11*year),30);

-    } else {
+    } else if(cType==ASTRONOMICAL){

         return trueMonthStart(12*(year-1));
         return trueMonthStart(12*(year-1));

+    } else {
+        year -= UMALQURA_YEAR_START;
+        // rounded least-squares fit of the dates previously calculated from UMALQURA_MONTHLENGTH iteration
+        int32_t yrStartLinearEstimate = (int32_t)((354.36720 * (double)year) + 460322.05 + 0.5);
+        // need a slight correction to some
+        return yrStartLinearEstimate + umAlQuraYrStartEstimateFix[year];

     }
 }
 
     }
 }
 


@@ -209,14 +385,21 @@ int32_t IslamicCalendar::yearStart(int32_t year) {
 * from the Hijri epoch, origin 0.
 *
 * @param year  The hijri year
 * from the Hijri epoch, origin 0.
 *
 * @param year  The hijri year

-* @param year  The hijri month, 0-based
+* @param month The hijri month, 0-based (assumed to be in range 0..11)

 */
 int32_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {
 */
 int32_t IslamicCalendar::monthStart(int32_t year, int32_t month) const {

-    if (civil == CIVIL) {
+    if (cType == CIVIL || cType == TBLA) {
+        // This does not handle months out of the range 0..11

         return (int32_t)uprv_ceil(29.5*month)
             + (year-1)*354 + (int32_t)ClockMath::floorDivide((3+11*year),30);
         return (int32_t)uprv_ceil(29.5*month)
             + (year-1)*354 + (int32_t)ClockMath::floorDivide((3+11*year),30);

-    } else {
+    } else if(cType==ASTRONOMICAL){

         return trueMonthStart(12*(year-1) + month);
         return trueMonthStart(12*(year-1) + month);

+    } else {
+        int32_t ms = yearStart(year);
+        for(int i=0; i< month; i++){
+            ms+= handleGetMonthLength(year, i);
+        }
+        return ms;

     }
 }
 
     }
 }
 


@@ -287,7 +470,8 @@ double IslamicCalendar::moonAge(UDate time, UErrorCode &status)
 {
     double age = 0;
 
 {
     double age = 0;
 

-    umtx_lock(&astroLock);
+    static UMutex *astroLock = STATIC_NEW(UMutex);      // pod bay door lock
+    umtx_lock(astroLock);

     if(gIslamicCalendarAstro == NULL) {
         gIslamicCalendarAstro = new CalendarAstronomer();
         if (gIslamicCalendarAstro == NULL) {
     if(gIslamicCalendarAstro == NULL) {
         gIslamicCalendarAstro = new CalendarAstronomer();
         if (gIslamicCalendarAstro == NULL) {


@@ -298,7 +482,7 @@ double IslamicCalendar::moonAge(UDate time, UErrorCode &status)
     }
     gIslamicCalendarAstro->setTime(time);
     age = gIslamicCalendarAstro->getMoonAge();
     }
     gIslamicCalendarAstro->setTime(time);
     age = gIslamicCalendarAstro->getMoonAge();

-    umtx_unlock(&astroLock);
+    umtx_unlock(astroLock);

 
     // Convert to degrees and normalize...
     age = age * 180 / CalendarAstronomer::PI;
 
     // Convert to degrees and normalize...
     age = age * 180 / CalendarAstronomer::PI;


@@ -324,14 +508,17 @@ int32_t IslamicCalendar::handleGetMonthLength(int32_t extendedYear, int32_t mont
 
     int32_t length = 0;
 
 
     int32_t length = 0;
 

-    if (civil == CIVIL) {
+    if (cType == CIVIL || cType == TBLA ||
+        (cType == UMALQURA && (extendedYear<UMALQURA_YEAR_START || extendedYear>UMALQURA_YEAR_END)) ) {

         length = 29 + (month+1) % 2;
         if (month == DHU_AL_HIJJAH && civilLeapYear(extendedYear)) {
             length++;
         }
         length = 29 + (month+1) % 2;
         if (month == DHU_AL_HIJJAH && civilLeapYear(extendedYear)) {
             length++;
         }

-    } else {
+    } else if(cType == ASTRONOMICAL){

         month = 12*(extendedYear-1) + month;
         length =  trueMonthStart(month+1) - trueMonthStart(month) ;
         month = 12*(extendedYear-1) + month;
         length =  trueMonthStart(month+1) - trueMonthStart(month) ;

+    } else {
+        length = getUmalqura_MonthLength(extendedYear - UMALQURA_YEAR_START, month);

     }
     return length;
 }
     }
     return length;
 }


@@ -341,11 +528,18 @@ int32_t IslamicCalendar::handleGetMonthLength(int32_t extendedYear, int32_t mont
 * @draft ICU 2.4
 */
 int32_t IslamicCalendar::handleGetYearLength(int32_t extendedYear) const {
 * @draft ICU 2.4
 */
 int32_t IslamicCalendar::handleGetYearLength(int32_t extendedYear) const {

-    if (civil == CIVIL) {
+    if (cType == CIVIL || cType == TBLA ||
+        (cType == UMALQURA && (extendedYear<UMALQURA_YEAR_START || extendedYear>UMALQURA_YEAR_END)) ) {

         return 354 + (civilLeapYear(extendedYear) ? 1 : 0);
         return 354 + (civilLeapYear(extendedYear) ? 1 : 0);

-    } else {
+    } else if(cType == ASTRONOMICAL){

         int32_t month = 12*(extendedYear-1);
         return (trueMonthStart(month + 12) - trueMonthStart(month));
         int32_t month = 12*(extendedYear-1);
         return (trueMonthStart(month + 12) - trueMonthStart(month));

+    } else {
+        int len = 0;
+        for(int i=0; i<12; i++) {
+            len += handleGetMonthLength(extendedYear, i);
+        }
+        return len;

     }
 }
 
     }
 }
 


@@ -354,11 +548,25 @@ int32_t IslamicCalendar::handleGetYearLength(int32_t extendedYear) const {
 //-------------------------------------------------------------------------
 
 // Return JD of start of given month/year
 //-------------------------------------------------------------------------
 
 // Return JD of start of given month/year

+// Calendar says:
+// Get the Julian day of the day BEFORE the start of this year.
+// If useMonth is true, get the day before the start of the month.
+// Hence the -1

 /**
 * @draft ICU 2.4
 */
 int32_t IslamicCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */) const {
 /**
 * @draft ICU 2.4
 */
 int32_t IslamicCalendar::handleComputeMonthStart(int32_t eyear, int32_t month, UBool /* useMonth */) const {

-    return monthStart(eyear, month) + 1948439;
+    // This may be called by Calendar::handleComputeJulianDay with months out of the range
+    // 0..11. Need to handle that here since monthStart requires months in the range 0.11.
+    if (month > 11) {
+        eyear += (month / 12);
+        month %= 12;
+    } else if (month < 0) {
+        month++;
+        eyear += (month / 12) - 1;
+        month = (month % 12) + 11;
+    }
+    return monthStart(eyear, month) + ((cType == TBLA)? ASTRONOMICAL_EPOC: CIVIL_EPOC) - 1;

 }    
 
 //-------------------------------------------------------------------------
 }    
 
 //-------------------------------------------------------------------------


@@ -396,25 +604,28 @@ int32_t IslamicCalendar::handleGetExtendedYear() {
 */
 void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
     int32_t year, month, dayOfMonth, dayOfYear;
 */
 void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status) {
     int32_t year, month, dayOfMonth, dayOfYear;

-    UDate startDate;
-    int32_t days = julianDay - 1948440;
+    int32_t startDate;
+    int32_t days = julianDay - CIVIL_EPOC;

 
 

-    if (civil == CIVIL) {
+    if (cType == CIVIL || cType == TBLA) {
+        if(cType == TBLA) {
+            days = julianDay - ASTRONOMICAL_EPOC;
+        }

         // Use the civil calendar approximation, which is just arithmetic
         // Use the civil calendar approximation, which is just arithmetic

-        year  = (int)ClockMath::floorDivide( (double)(30 * days + 10646) , 10631.0 );
+        year  = (int32_t)ClockMath::floorDivide(30 * (int64_t)days + 10646, (int64_t)10631);

         month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
         month = month<11?month:11;
         startDate = monthStart(year, month);
         month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
         month = month<11?month:11;
         startDate = monthStart(year, month);

-    } else {
+    } else if(cType == ASTRONOMICAL){

         // Guess at the number of elapsed full months since the epoch
         int32_t months = (int32_t)uprv_floor((double)days / CalendarAstronomer::SYNODIC_MONTH);
 
         // Guess at the number of elapsed full months since the epoch
         int32_t months = (int32_t)uprv_floor((double)days / CalendarAstronomer::SYNODIC_MONTH);
 

-        startDate = uprv_floor(months * CalendarAstronomer::SYNODIC_MONTH);
+        startDate = (int32_t)uprv_floor(months * CalendarAstronomer::SYNODIC_MONTH);

 
         double age = moonAge(internalGetTime(), status);
         if (U_FAILURE(status)) {
 
         double age = moonAge(internalGetTime(), status);
         if (U_FAILURE(status)) {

-               status = U_MEMORY_ALLOCATION_ERROR;
-               return;
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;

         }
         if ( days - startDate >= 25 && age > 0) {
             // If we're near the end of the month, assume next month and search backwards
         }
         if ( days - startDate >= 25 && age > 0) {
             // If we're near the end of the month, assume next month and search backwards


@@ -430,12 +641,46 @@ void IslamicCalendar::handleComputeFields(int32_t julianDay, UErrorCode &status)
 
         year = months / 12 + 1;
         month = months % 12;
 
         year = months / 12 + 1;
         month = months % 12;

+    } else if(cType == UMALQURA) {
+        int32_t umalquraStartdays = yearStart(UMALQURA_YEAR_START) ;
+        if( days < umalquraStartdays){
+                //Use Civil calculation
+                year  = (int)ClockMath::floorDivide( (double)(30 * days + 10646) , 10631.0 );
+                month = (int32_t)uprv_ceil((days - 29 - yearStart(year)) / 29.5 );
+                month = month<11?month:11;
+                startDate = monthStart(year, month);
+            }else{
+                int y =UMALQURA_YEAR_START-1, m =0;
+                long d = 1;
+                while(d > 0){ 
+                    y++; 
+                    d = days - yearStart(y) +1;
+                    if(d == handleGetYearLength(y)){
+                        m=11;
+                        break;
+                    }else if(d < handleGetYearLength(y) ){
+                        int monthLen = handleGetMonthLength(y, m); 
+                        m=0;
+                        while(d > monthLen){
+                            d -= monthLen;
+                            m++;
+                            monthLen = handleGetMonthLength(y, m);
+                        }
+                        break;
+                    }
+                }
+                year = y;
+                month = m;
+            }
+    } else { // invalid 'civil'
+      UPRV_UNREACHABLE; // should not get here, out of range

     }
 
     dayOfMonth = (days - monthStart(year, month)) + 1;
 
     // Now figure out the day of the year.
     }
 
     dayOfMonth = (days - monthStart(year, month)) + 1;
 
     // Now figure out the day of the year.

-    dayOfYear = (days - monthStart(year, 0) + 1);
+    dayOfYear = (days - monthStart(year, 0)) + 1;
+

 
     internalSet(UCAL_ERA, 0);
     internalSet(UCAL_YEAR, year);
 
     internalSet(UCAL_ERA, 0);
     internalSet(UCAL_YEAR, year);


@@ -449,7 +694,7 @@ UBool
 IslamicCalendar::inDaylightTime(UErrorCode& status) const
 {
     // copied from GregorianCalendar
 IslamicCalendar::inDaylightTime(UErrorCode& status) const
 {
     // copied from GregorianCalendar

-    if (U_FAILURE(status) || (&(getTimeZone()) == NULL && !getTimeZone().useDaylightTime())) 
+    if (U_FAILURE(status) || !getTimeZone().useDaylightTime()) 

         return FALSE;
 
     // Force an update of the state of the Calendar.
         return FALSE;
 
     // Force an update of the state of the Calendar.


@@ -458,12 +703,14 @@ IslamicCalendar::inDaylightTime(UErrorCode& status) const
     return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE);
 }
 
     return (UBool)(U_SUCCESS(status) ? (internalGet(UCAL_DST_OFFSET) != 0) : FALSE);
 }
 

-// default century
-const UDate     IslamicCalendar::fgSystemDefaultCentury        = DBL_MIN;
-const int32_t   IslamicCalendar::fgSystemDefaultCenturyYear    = -1;
-
-UDate           IslamicCalendar::fgSystemDefaultCenturyStart       = DBL_MIN;
-int32_t         IslamicCalendar::fgSystemDefaultCenturyStartYear   = -1;
+/**
+ * The system maintains a static default century start date and Year.  They are
+ * initialized the first time they are used.  Once the system default century date 
+ * and year are set, they do not change.
+ */
+static UDate           gSystemDefaultCenturyStart       = DBL_MIN;
+static int32_t         gSystemDefaultCenturyStartYear   = -1;
+static icu::UInitOnce  gSystemDefaultCenturyInit        = U_INITONCE_INITIALIZER;

 
 
 UBool IslamicCalendar::haveDefaultCentury() const
 
 
 UBool IslamicCalendar::haveDefaultCentury() const


@@ -472,50 +719,21 @@ UBool IslamicCalendar::haveDefaultCentury() const
 }
 
 UDate IslamicCalendar::defaultCenturyStart() const
 }
 
 UDate IslamicCalendar::defaultCenturyStart() const

-{
-    return internalGetDefaultCenturyStart();
-}
-
-int32_t IslamicCalendar::defaultCenturyStartYear() const
-{
-    return internalGetDefaultCenturyStartYear();
-}
-
-UDate
-IslamicCalendar::internalGetDefaultCenturyStart() const

 {
     // lazy-evaluate systemDefaultCenturyStart
 {
     // lazy-evaluate systemDefaultCenturyStart

-    UBool needsUpdate;
-    UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate);
-
-    if (needsUpdate) {
-        initializeSystemDefaultCentury();
-    }
-
-    // use defaultCenturyStart unless it's the flag value;
-    // then use systemDefaultCenturyStart
-
-    return fgSystemDefaultCenturyStart;
+    umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
+    return gSystemDefaultCenturyStart;

 }
 
 }
 

-int32_t
-IslamicCalendar::internalGetDefaultCenturyStartYear() const
+int32_t IslamicCalendar::defaultCenturyStartYear() const

 {
     // lazy-evaluate systemDefaultCenturyStartYear
 {
     // lazy-evaluate systemDefaultCenturyStartYear

-    UBool needsUpdate;
-    UMTX_CHECK(NULL, (fgSystemDefaultCenturyStart == fgSystemDefaultCentury), needsUpdate);
-
-    if (needsUpdate) {
-        initializeSystemDefaultCentury();
-    }
-
-    // use defaultCenturyStart unless it's the flag value;
-    // then use systemDefaultCenturyStartYear
-
-    return    fgSystemDefaultCenturyStartYear;
+    umtx_initOnce(gSystemDefaultCenturyInit, &initializeSystemDefaultCentury);
+    return gSystemDefaultCenturyStartYear;

 }
 
 }
 

-void
+
+U_CFUNC void U_CALLCONV

 IslamicCalendar::initializeSystemDefaultCentury()
 {
     // initialize systemDefaultCentury and systemDefaultCenturyYear based
 IslamicCalendar::initializeSystemDefaultCentury()
 {
     // initialize systemDefaultCentury and systemDefaultCenturyYear based


@@ -523,24 +741,19 @@ IslamicCalendar::initializeSystemDefaultCentury()
     // the current time.
     UErrorCode status = U_ZERO_ERROR;
     IslamicCalendar calendar(Locale("@calendar=islamic-civil"),status);
     // the current time.
     UErrorCode status = U_ZERO_ERROR;
     IslamicCalendar calendar(Locale("@calendar=islamic-civil"),status);

-    if (U_SUCCESS(status))
-    {
+    if (U_SUCCESS(status)) {

         calendar.setTime(Calendar::getNow(), status);
         calendar.add(UCAL_YEAR, -80, status);
         calendar.setTime(Calendar::getNow(), status);
         calendar.add(UCAL_YEAR, -80, status);

-        UDate    newStart =  calendar.getTime(status);
-        int32_t  newYear  =  calendar.get(UCAL_YEAR, status);
-        umtx_lock(NULL);
-        if (fgSystemDefaultCenturyStart == fgSystemDefaultCentury)
-        {
-            fgSystemDefaultCenturyStartYear = newYear;
-            fgSystemDefaultCenturyStart = newStart;
-        }
-        umtx_unlock(NULL);
+
+        gSystemDefaultCenturyStart = calendar.getTime(status);
+        gSystemDefaultCenturyStartYear = calendar.get(UCAL_YEAR, status);

     }
     // We have no recourse upon failure unless we want to propagate the failure
     // out.
 }
 
     }
     // We have no recourse upon failure unless we want to propagate the failure
     // out.
 }
 

+
+

 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IslamicCalendar)
 
 U_NAMESPACE_END
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(IslamicCalendar)
 
 U_NAMESPACE_END