Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 831 insertions, 0 deletions

diff --git a/intl/icu/source/i18n/ucal.cpp b/intl/icu/source/i18n/ucal.cpp
new file mode 100644
index 0000000000..67c51aea27
--- /dev/null
+++ b/intl/icu/source/i18n/ucal.cpp
@@ -0,0 +1,831 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+*******************************************************************************
+*   Copyright (C) 1996-2016, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*******************************************************************************
+*/
+
+#include "utypeinfo.h"  // for 'typeid' to work
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/ucal.h"
+#include "unicode/uloc.h"
+#include "unicode/calendar.h"
+#include "unicode/timezone.h"
+#include "unicode/gregocal.h"
+#include "unicode/simpletz.h"
+#include "unicode/ustring.h"
+#include "unicode/strenum.h"
+#include "unicode/localpointer.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "ustrenum.h"
+#include "uenumimp.h"
+#include "ulist.h"
+#include "ulocimp.h"
+
+U_NAMESPACE_USE
+
+static TimeZone*
+_createTimeZone(const UChar* zoneID, int32_t len, UErrorCode* ec) {
+    TimeZone* zone = NULL;
+    if (ec != NULL && U_SUCCESS(*ec)) {
+        // Note that if zoneID is invalid, we get back GMT. This odd
+        // behavior is by design and goes back to the JDK. The only
+        // failure we will see is a memory allocation failure.
+        int32_t l = (len<0 ? u_strlen(zoneID) : len);
+        UnicodeString zoneStrID;
+        zoneStrID.setTo((UBool)(len < 0), zoneID, l); /* temporary read-only alias */
+        zone = TimeZone::createTimeZone(zoneStrID);
+        if (zone == NULL) {
+            *ec = U_MEMORY_ALLOCATION_ERROR;
+        }
+    }
+    return zone;
+}
+
+U_CAPI UEnumeration* U_EXPORT2
+ucal_openTimeZoneIDEnumeration(USystemTimeZoneType zoneType, const char* region,
+                                const int32_t* rawOffset, UErrorCode* ec) {
+    return uenum_openFromStringEnumeration(TimeZone::createTimeZoneIDEnumeration(
+        zoneType, region, rawOffset, *ec), ec);
+}
+
+U_CAPI UEnumeration* U_EXPORT2
+ucal_openTimeZones(UErrorCode* ec) {
+    return uenum_openFromStringEnumeration(TimeZone::createEnumeration(), ec);
+}
+
+U_CAPI UEnumeration* U_EXPORT2
+ucal_openCountryTimeZones(const char* country, UErrorCode* ec) {
+    return uenum_openFromStringEnumeration(TimeZone::createEnumeration(country), ec);
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getDefaultTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
+    int32_t len = 0;
+    if (ec != NULL && U_SUCCESS(*ec)) {
+        TimeZone* zone = TimeZone::createDefault();
+        if (zone == NULL) {
+            *ec = U_MEMORY_ALLOCATION_ERROR;
+        } else {
+            UnicodeString id;
+            zone->getID(id);
+            delete zone;
+            len = id.extract(result, resultCapacity, *ec);
+        }
+    }
+    return len;
+}
+
+U_CAPI void U_EXPORT2
+ucal_setDefaultTimeZone(const UChar* zoneID, UErrorCode* ec) {
+    TimeZone* zone = _createTimeZone(zoneID, -1, ec);
+    if (zone != NULL) {
+        TimeZone::adoptDefault(zone);
+    }
+}
+
+U_DRAFT int32_t U_EXPORT2
+ucal_getHostTimeZone(UChar* result, int32_t resultCapacity, UErrorCode* ec) {
+    int32_t len = 0;
+    if (ec != NULL && U_SUCCESS(*ec)) {
+        TimeZone *zone = TimeZone::detectHostTimeZone();
+        if (zone == NULL) {
+            *ec = U_MEMORY_ALLOCATION_ERROR;
+        } else {
+            UnicodeString id;
+            zone->getID(id);
+            delete zone;
+            len = id.extract(result, resultCapacity, *ec);
+        }
+    }
+    return len;
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getDSTSavings(const UChar* zoneID, UErrorCode* ec) {
+    int32_t result = 0;
+    TimeZone* zone = _createTimeZone(zoneID, -1, ec);
+    if (U_SUCCESS(*ec)) {
+        SimpleTimeZone* stz = dynamic_cast<SimpleTimeZone*>(zone);
+        if (stz != NULL) {
+            result = stz->getDSTSavings();
+        } else {
+            // Since there is no getDSTSavings on TimeZone, we use a
+            // heuristic: Starting with the current time, march
+            // forwards for one year, looking for DST savings.
+            // Stepping by weeks is sufficient.
+            UDate d = Calendar::getNow();
+            for (int32_t i=0; i<53; ++i, d+=U_MILLIS_PER_DAY*7.0) {
+                int32_t raw, dst;
+                zone->getOffset(d, FALSE, raw, dst, *ec);
+                if (U_FAILURE(*ec)) {
+                    break;
+                } else if (dst != 0) {
+                    result = dst;
+                    break;
+                }
+            }
+        }
+    }
+    delete zone;
+    return result;
+}
+
+U_CAPI UDate  U_EXPORT2
+ucal_getNow()
+{
+
+  return Calendar::getNow();
+}
+
+#define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
+
+U_CAPI UCalendar*  U_EXPORT2
+ucal_open(  const UChar*  zoneID,
+            int32_t       len,
+            const char*   locale,
+            UCalendarType caltype,
+            UErrorCode*   status)
+{
+  if (U_FAILURE(*status)) {
+      return nullptr;
+  }
+  
+  LocalPointer<TimeZone> zone( (zoneID==nullptr) ? TimeZone::createDefault() 
+      : _createTimeZone(zoneID, len, status), *status);
+
+  if (U_FAILURE(*status)) {
+      return nullptr;
+  }
+
+  if ( caltype == UCAL_GREGORIAN ) {
+      char localeBuf[ULOC_LOCALE_IDENTIFIER_CAPACITY];
+      if ( locale == nullptr ) {
+          locale = uloc_getDefault();
+      }
+      int32_t localeLength = static_cast<int32_t>(uprv_strlen(locale));
+      if (localeLength >= ULOC_LOCALE_IDENTIFIER_CAPACITY) {
+          *status = U_ILLEGAL_ARGUMENT_ERROR;
+          return nullptr;
+      }
+      uprv_strcpy(localeBuf, locale);
+      uloc_setKeywordValue("calendar", "gregorian", localeBuf, ULOC_LOCALE_IDENTIFIER_CAPACITY, status);
+      if (U_FAILURE(*status)) {
+          return nullptr;
+      }
+      return (UCalendar*)Calendar::createInstance(zone.orphan(), Locale(localeBuf), *status);
+  }
+  return (UCalendar*)Calendar::createInstance(zone.orphan(), Locale(locale), *status);
+}
+
+U_CAPI void U_EXPORT2
+ucal_close(UCalendar *cal)
+{
+    if (cal != nullptr) {
+        delete (Calendar*) cal;
+    }
+}
+
+U_CAPI UCalendar* U_EXPORT2 
+ucal_clone(const UCalendar* cal,
+           UErrorCode*      status)
+{
+  if(U_FAILURE(*status)) return 0;
+  
+  Calendar* res = ((Calendar*)cal)->clone();
+
+  if(res == 0) {
+    *status = U_MEMORY_ALLOCATION_ERROR;
+    return 0;
+  }
+
+  return (UCalendar*) res;
+}
+
+U_CAPI void  U_EXPORT2
+ucal_setTimeZone(    UCalendar*      cal,
+            const    UChar*            zoneID,
+            int32_t        len,
+            UErrorCode *status)
+{
+
+  if(U_FAILURE(*status))
+    return;
+
+  TimeZone* zone = (zoneID==NULL) ? TimeZone::createDefault()
+      : _createTimeZone(zoneID, len, status);
+
+  if (zone != NULL) {
+      ((Calendar*)cal)->adoptTimeZone(zone);
+  }
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getTimeZoneID(const UCalendar *cal,
+                   UChar *result,
+                   int32_t resultLength,
+                   UErrorCode *status)
+{
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+    const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
+    UnicodeString id;
+    tz.getID(id);
+    return id.extract(result, resultLength, *status);
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getTimeZoneDisplayName(const     UCalendar*                 cal,
+                    UCalendarDisplayNameType     type,
+                    const char             *locale,
+                    UChar*                  result,
+                    int32_t                 resultLength,
+                    UErrorCode*             status)
+{
+
+    if(U_FAILURE(*status)) return -1;
+
+    const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
+    UnicodeString id;
+    if(!(result==NULL && resultLength==0)) {
+        // NULL destination for pure preflighting: empty dummy string
+        // otherwise, alias the destination buffer
+        id.setTo(result, 0, resultLength);
+    }
+
+    switch(type) {
+  case UCAL_STANDARD:
+      tz.getDisplayName(FALSE, TimeZone::LONG, Locale(locale), id);
+      break;
+
+  case UCAL_SHORT_STANDARD:
+      tz.getDisplayName(FALSE, TimeZone::SHORT, Locale(locale), id);
+      break;
+
+  case UCAL_DST:
+      tz.getDisplayName(TRUE, TimeZone::LONG, Locale(locale), id);
+      break;
+
+  case UCAL_SHORT_DST:
+      tz.getDisplayName(TRUE, TimeZone::SHORT, Locale(locale), id);
+      break;
+    }
+
+    return id.extract(result, resultLength, *status);
+}
+
+U_CAPI UBool  U_EXPORT2
+ucal_inDaylightTime(    const    UCalendar*      cal, 
+                    UErrorCode*     status )
+{
+
+    if(U_FAILURE(*status)) return (UBool) -1;
+    return ((Calendar*)cal)->inDaylightTime(*status);
+}
+
+U_CAPI void U_EXPORT2
+ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode) {
+    if(U_FAILURE(*pErrorCode)) {
+        return;
+    }
+    Calendar *cpp_cal = (Calendar *)cal;
+    GregorianCalendar *gregocal = dynamic_cast<GregorianCalendar *>(cpp_cal);
+    // Not if(gregocal == NULL) {
+    // because we really want to work only with a GregorianCalendar, not with
+    // its subclasses like BuddhistCalendar.
+    if (cpp_cal == NULL) {
+        // We normally don't check "this" pointers for NULL, but this here avoids
+        // compiler-generated exception-throwing code in case cal == NULL.
+        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
+    if(typeid(*cpp_cal) != typeid(GregorianCalendar)) {
+        *pErrorCode = U_UNSUPPORTED_ERROR;
+        return;
+    }
+    gregocal->setGregorianChange(date, *pErrorCode);
+}
+
+U_CAPI UDate U_EXPORT2
+ucal_getGregorianChange(const UCalendar *cal, UErrorCode *pErrorCode) {
+    if(U_FAILURE(*pErrorCode)) {
+        return (UDate)0;
+    }
+    const Calendar *cpp_cal = (const Calendar *)cal;
+    const GregorianCalendar *gregocal = dynamic_cast<const GregorianCalendar *>(cpp_cal);
+    // Not if(gregocal == NULL) {
+    // see comments in ucal_setGregorianChange().
+    if (cpp_cal == NULL) {
+        // We normally don't check "this" pointers for NULL, but this here avoids
+        // compiler-generated exception-throwing code in case cal == NULL.
+        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+        return (UDate)0;
+    }
+    if(typeid(*cpp_cal) != typeid(GregorianCalendar)) {
+        *pErrorCode = U_UNSUPPORTED_ERROR;
+        return (UDate)0;
+    }
+    return gregocal->getGregorianChange();
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getAttribute(    const    UCalendar*              cal,
+                  UCalendarAttribute      attr)
+{
+
+    switch(attr) {
+  case UCAL_LENIENT:
+      return ((Calendar*)cal)->isLenient();
+
+  case UCAL_FIRST_DAY_OF_WEEK:
+      return ((Calendar*)cal)->getFirstDayOfWeek();
+
+  case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
+      return ((Calendar*)cal)->getMinimalDaysInFirstWeek();
+
+  case UCAL_REPEATED_WALL_TIME:
+      return ((Calendar*)cal)->getRepeatedWallTimeOption();
+
+  case UCAL_SKIPPED_WALL_TIME:
+      return ((Calendar*)cal)->getSkippedWallTimeOption();
+
+  default:
+      break;
+    }
+    return -1;
+}
+
+U_CAPI void U_EXPORT2
+ucal_setAttribute(      UCalendar*              cal,
+                  UCalendarAttribute      attr,
+                  int32_t                 newValue)
+{
+
+    switch(attr) {
+  case UCAL_LENIENT:
+      ((Calendar*)cal)->setLenient((UBool)newValue);
+      break;
+
+  case UCAL_FIRST_DAY_OF_WEEK:
+      ((Calendar*)cal)->setFirstDayOfWeek((UCalendarDaysOfWeek)newValue);
+      break;
+
+  case UCAL_MINIMAL_DAYS_IN_FIRST_WEEK:
+      ((Calendar*)cal)->setMinimalDaysInFirstWeek((uint8_t)newValue);
+      break;
+
+  case UCAL_REPEATED_WALL_TIME:
+      ((Calendar*)cal)->setRepeatedWallTimeOption((UCalendarWallTimeOption)newValue);
+      break;
+
+  case UCAL_SKIPPED_WALL_TIME:
+      ((Calendar*)cal)->setSkippedWallTimeOption((UCalendarWallTimeOption)newValue);
+      break;
+    }
+}
+
+U_CAPI const char* U_EXPORT2
+ucal_getAvailable(int32_t index)
+{
+
+    return uloc_getAvailable(index);
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_countAvailable()
+{
+
+    return uloc_countAvailable();
+}
+
+U_CAPI UDate  U_EXPORT2
+ucal_getMillis(    const    UCalendar*      cal,
+               UErrorCode*     status)
+{
+
+    if(U_FAILURE(*status)) return (UDate) 0;
+
+    return ((Calendar*)cal)->getTime(*status);
+}
+
+U_CAPI void  U_EXPORT2
+ucal_setMillis(        UCalendar*      cal,
+               UDate           dateTime,
+               UErrorCode*     status )
+{
+    if(U_FAILURE(*status)) return;
+
+    ((Calendar*)cal)->setTime(dateTime, *status);
+}
+
+// TBD: why does this take an UErrorCode?
+U_CAPI void  U_EXPORT2
+ucal_setDate(        UCalendar*        cal,
+             int32_t            year,
+             int32_t            month,
+             int32_t            date,
+             UErrorCode        *status)
+{
+
+    if(U_FAILURE(*status)) return;
+
+    ((Calendar*)cal)->set(year, month, date);
+}
+
+// TBD: why does this take an UErrorCode?
+U_CAPI void  U_EXPORT2
+ucal_setDateTime(    UCalendar*        cal,
+                 int32_t            year,
+                 int32_t            month,
+                 int32_t            date,
+                 int32_t            hour,
+                 int32_t            minute,
+                 int32_t            second,
+                 UErrorCode        *status)
+{
+    if(U_FAILURE(*status)) return;
+
+    ((Calendar*)cal)->set(year, month, date, hour, minute, second);
+}
+
+U_CAPI UBool  U_EXPORT2
+ucal_equivalentTo(    const UCalendar*      cal1,
+                  const UCalendar*      cal2)
+{
+
+    return ((Calendar*)cal1)->isEquivalentTo(*((Calendar*)cal2));
+}
+
+U_CAPI void  U_EXPORT2
+ucal_add(    UCalendar*                cal,
+         UCalendarDateFields        field,
+         int32_t                    amount,
+         UErrorCode*                status)
+{
+
+    if(U_FAILURE(*status)) return;
+
+    ((Calendar*)cal)->add(field, amount, *status);
+}
+
+U_CAPI void  U_EXPORT2
+ucal_roll(        UCalendar*            cal,
+          UCalendarDateFields field,
+          int32_t                amount,
+          UErrorCode*            status)
+{
+
+    if(U_FAILURE(*status)) return;
+
+    ((Calendar*)cal)->roll(field, amount, *status);
+}
+
+U_CAPI int32_t  U_EXPORT2
+ucal_get(    const    UCalendar*                cal,
+         UCalendarDateFields        field,
+         UErrorCode*                status )
+{
+
+    if(U_FAILURE(*status)) return -1;
+
+    return ((Calendar*)cal)->get(field, *status);
+}
+
+U_CAPI void  U_EXPORT2
+ucal_set(    UCalendar*                cal,
+         UCalendarDateFields        field,
+         int32_t                    value)
+{
+
+    ((Calendar*)cal)->set(field, value);
+}
+
+U_CAPI UBool  U_EXPORT2
+ucal_isSet(    const    UCalendar*                cal,
+           UCalendarDateFields        field)
+{
+
+    return ((Calendar*)cal)->isSet(field);
+}
+
+U_CAPI void  U_EXPORT2
+ucal_clearField(    UCalendar*            cal,
+                UCalendarDateFields field)
+{
+
+    ((Calendar*)cal)->clear(field);
+}
+
+U_CAPI void  U_EXPORT2
+ucal_clear(UCalendar* calendar)
+{
+
+    ((Calendar*)calendar)->clear();
+}
+
+U_CAPI int32_t  U_EXPORT2
+ucal_getLimit(    const    UCalendar*              cal,
+              UCalendarDateFields     field,
+              UCalendarLimitType      type,
+              UErrorCode        *status)
+{
+
+    if(status==0 || U_FAILURE(*status)) {
+        return -1;
+    }
+
+    switch(type) {
+  case UCAL_MINIMUM:
+      return ((Calendar*)cal)->getMinimum(field);
+
+  case UCAL_MAXIMUM:
+      return ((Calendar*)cal)->getMaximum(field);
+
+  case UCAL_GREATEST_MINIMUM:
+      return ((Calendar*)cal)->getGreatestMinimum(field);
+
+  case UCAL_LEAST_MAXIMUM:
+      return ((Calendar*)cal)->getLeastMaximum(field);
+
+  case UCAL_ACTUAL_MINIMUM:
+      return ((Calendar*)cal)->getActualMinimum(field,
+          *status);
+
+  case UCAL_ACTUAL_MAXIMUM:
+      return ((Calendar*)cal)->getActualMaximum(field,
+          *status);
+
+  default:
+      break;
+    }
+    return -1;
+}
+
+U_CAPI const char * U_EXPORT2
+ucal_getLocaleByType(const UCalendar *cal, ULocDataLocaleType type, UErrorCode* status) 
+{
+    if (cal == NULL) {
+        if (U_SUCCESS(*status)) {
+            *status = U_ILLEGAL_ARGUMENT_ERROR;
+        }
+        return NULL;
+    }
+    return ((Calendar*)cal)->getLocaleID(type, *status);
+}
+
+U_CAPI const char * U_EXPORT2
+ucal_getTZDataVersion(UErrorCode* status)
+{
+    return TimeZone::getTZDataVersion(*status);
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len,
+                            UChar* result, int32_t resultCapacity, UBool *isSystemID, UErrorCode* status) {
+    if(status == 0 || U_FAILURE(*status)) {
+        return 0;
+    }
+    if (isSystemID) {
+        *isSystemID = FALSE;
+    }
+    if (id == 0 || len == 0 || result == 0 || resultCapacity <= 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
+    int32_t reslen = 0;
+    UnicodeString canonical;
+    UBool systemID = FALSE;
+    TimeZone::getCanonicalID(UnicodeString(id, len), canonical, systemID, *status);
+    if (U_SUCCESS(*status)) {
+        if (isSystemID) {
+            *isSystemID = systemID;
+        }
+        reslen = canonical.extract(result, resultCapacity, *status);
+    }
+    return reslen;
+}
+
+U_CAPI const char * U_EXPORT2
+ucal_getType(const UCalendar *cal, UErrorCode* status)
+{
+    if (U_FAILURE(*status)) {
+        return NULL;
+    }
+    return ((Calendar*)cal)->getType();
+}
+
+U_CAPI UCalendarWeekdayType U_EXPORT2
+ucal_getDayOfWeekType(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode* status)
+{
+    if (U_FAILURE(*status)) {
+        return UCAL_WEEKDAY;
+    }
+    return ((Calendar*)cal)->getDayOfWeekType(dayOfWeek, *status);
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getWeekendTransition(const UCalendar *cal, UCalendarDaysOfWeek dayOfWeek, UErrorCode *status)
+{
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+    return ((Calendar*)cal)->getWeekendTransition(dayOfWeek, *status);
+}
+
+U_CAPI UBool U_EXPORT2
+ucal_isWeekend(const UCalendar *cal, UDate date, UErrorCode *status)
+{
+    if (U_FAILURE(*status)) {
+        return FALSE;
+    }
+    return ((Calendar*)cal)->isWeekend(date, *status);
+}
+
+U_CAPI int32_t  U_EXPORT2
+ucal_getFieldDifference(UCalendar* cal, UDate target,
+                        UCalendarDateFields field,
+                        UErrorCode* status )
+{
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+    return ((Calendar*)cal)->fieldDifference(target, field, *status);
+}
+
+
+static const UEnumeration defaultKeywordValues = {
+    NULL,
+    NULL,
+    ulist_close_keyword_values_iterator,
+    ulist_count_keyword_values,
+    uenum_unextDefault,
+    ulist_next_keyword_value, 
+    ulist_reset_keyword_values_iterator
+};
+
+static const char * const CAL_TYPES[] = {
+        "gregorian",
+        "japanese",
+        "buddhist",
+        "roc",
+        "persian",
+        "islamic-civil",
+        "islamic",
+        "hebrew",
+        "chinese",
+        "indian",
+        "coptic",
+        "ethiopic",
+        "ethiopic-amete-alem",
+        "iso8601",
+        "dangi",
+        "islamic-umalqura",
+        "islamic-tbla",
+        "islamic-rgsa",
+        NULL
+};
+
+U_CAPI UEnumeration* U_EXPORT2
+ucal_getKeywordValuesForLocale(const char * /* key */, const char* locale, UBool commonlyUsed, UErrorCode *status) {
+    // Resolve region
+    char prefRegion[ULOC_COUNTRY_CAPACITY];
+    (void)ulocimp_getRegionForSupplementalData(locale, TRUE, prefRegion, sizeof(prefRegion), status);
+    
+    // Read preferred calendar values from supplementalData calendarPreference
+    UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", status);
+    ures_getByKey(rb, "calendarPreferenceData", rb, status);
+    UResourceBundle *order = ures_getByKey(rb, prefRegion, NULL, status);
+    if (*status == U_MISSING_RESOURCE_ERROR && rb != NULL) {
+        *status = U_ZERO_ERROR;
+        order = ures_getByKey(rb, "001", NULL, status);
+    }
+
+    // Create a list of calendar type strings
+    UList *values = NULL;
+    if (U_SUCCESS(*status)) {
+        values = ulist_createEmptyList(status);
+        if (U_SUCCESS(*status)) {
+            for (int i = 0; i < ures_getSize(order); i++) {
+                int32_t len;
+                const UChar *type = ures_getStringByIndex(order, i, &len, status);
+                char *caltype = (char*)uprv_malloc(len + 1);
+                if (caltype == NULL) {
+                    *status = U_MEMORY_ALLOCATION_ERROR;
+                    break;
+                }
+                u_UCharsToChars(type, caltype, len);
+                *(caltype + len) = 0;
+
+                ulist_addItemEndList(values, caltype, TRUE, status);
+                if (U_FAILURE(*status)) {
+                    break;
+                }
+            }
+
+            if (U_SUCCESS(*status) && !commonlyUsed) {
+                // If not commonlyUsed, add other available values
+                for (int32_t i = 0; CAL_TYPES[i] != NULL; i++) {
+                    if (!ulist_containsString(values, CAL_TYPES[i], (int32_t)uprv_strlen(CAL_TYPES[i]))) {
+                        ulist_addItemEndList(values, CAL_TYPES[i], FALSE, status);
+                        if (U_FAILURE(*status)) {
+                            break;
+                        }
+                    }
+                }
+            }
+            if (U_FAILURE(*status)) {
+                ulist_deleteList(values);
+                values = NULL;
+            }
+        }
+    }
+
+    ures_close(order);
+    ures_close(rb);
+
+    if (U_FAILURE(*status) || values == NULL) {
+        return NULL;
+    }
+
+    // Create string enumeration
+    UEnumeration *en = (UEnumeration*)uprv_malloc(sizeof(UEnumeration));
+    if (en == NULL) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        ulist_deleteList(values);
+        return NULL;
+    }
+    ulist_resetList(values);
+    memcpy(en, &defaultKeywordValues, sizeof(UEnumeration));
+    en->context = values;
+    return en;
+}
+
+U_CAPI UBool U_EXPORT2 
+ucal_getTimeZoneTransitionDate(const UCalendar* cal, UTimeZoneTransitionType type,
+                               UDate* transition, UErrorCode* status)
+{
+    if (U_FAILURE(*status)) {
+        return FALSE;
+    }
+    UDate base = ((Calendar*)cal)->getTime(*status);
+    const TimeZone& tz = ((Calendar*)cal)->getTimeZone();
+    const BasicTimeZone * btz = dynamic_cast<const BasicTimeZone *>(&tz);
+    if (btz != NULL && U_SUCCESS(*status)) {
+        TimeZoneTransition tzt;
+        UBool inclusive = (type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE || type == UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE);
+        UBool result = (type == UCAL_TZ_TRANSITION_NEXT || type == UCAL_TZ_TRANSITION_NEXT_INCLUSIVE)?
+                        btz->getNextTransition(base, inclusive, tzt):
+                        btz->getPreviousTransition(base, inclusive, tzt);
+        if (result) {
+            *transition = tzt.getTime();
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getWindowsTimeZoneID(const UChar* id, int32_t len, UChar* winid, int32_t winidCapacity, UErrorCode* status) {
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+
+    int32_t resultLen = 0;
+    UnicodeString resultWinID;
+
+    TimeZone::getWindowsID(UnicodeString(id, len), resultWinID, *status);
+    if (U_SUCCESS(*status) && resultWinID.length() > 0) {
+        resultLen = resultWinID.length();
+        resultWinID.extract(winid, winidCapacity, *status);
+    }
+
+    return resultLen;
+}
+
+U_CAPI int32_t U_EXPORT2
+ucal_getTimeZoneIDForWindowsID(const UChar* winid, int32_t len, const char* region, UChar* id, int32_t idCapacity, UErrorCode* status) {
+    if (U_FAILURE(*status)) {
+        return 0;
+    }
+
+    int32_t resultLen = 0;
+    UnicodeString resultID;
+
+    TimeZone::getIDForWindowsID(UnicodeString(winid, len), region, resultID, *status);
+    if (U_SUCCESS(*status) && resultID.length() > 0) {
+        resultLen = resultID.length();
+        resultID.extract(id, idCapacity, *status);
+    }
+
+    return resultLen;
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */