| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1997-2013, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: locavailable.cpp |
| * encoding: UTF-8 |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2010feb25 |
| * created by: Markus W. Scherer |
| * |
| * Code for available locales, separated out from other .cpp files |
| * that then do not depend on resource bundle code and res_index bundles. |
| */ |
| |
| #if defined(STARBOARD) |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #include "starboard/client_porting/poem/string_poem.h" |
| #endif // defined(STARBOARD) |
| #include "unicode/errorcode.h" |
| #include "unicode/utypes.h" |
| #include "unicode/locid.h" |
| #include "unicode/uloc.h" |
| #include "unicode/ures.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "ucln_cmn.h" |
| #include "uassert.h" |
| #include "umutex.h" |
| #include "uresimp.h" |
| |
| // C++ API ----------------------------------------------------------------- *** |
| |
| U_NAMESPACE_BEGIN |
| |
| static icu::Locale* availableLocaleList = NULL; |
| static int32_t availableLocaleListCount; |
| static icu::UInitOnce gInitOnceLocale = U_INITONCE_INITIALIZER; |
| |
| U_NAMESPACE_END |
| |
| U_CDECL_BEGIN |
| |
| static UBool U_CALLCONV locale_available_cleanup(void) |
| { |
| U_NAMESPACE_USE |
| |
| if (availableLocaleList) { |
| delete []availableLocaleList; |
| availableLocaleList = NULL; |
| } |
| availableLocaleListCount = 0; |
| gInitOnceLocale.reset(); |
| |
| return TRUE; |
| } |
| |
| U_CDECL_END |
| |
| U_NAMESPACE_BEGIN |
| |
| void U_CALLCONV locale_available_init() { |
| // This function is a friend of class Locale. |
| // This function is only invoked via umtx_initOnce(). |
| |
| // for now, there is a hardcoded list, so just walk through that list and set it up. |
| // Note: this function is a friend of class Locale. |
| availableLocaleListCount = uloc_countAvailable(); |
| if(availableLocaleListCount) { |
| availableLocaleList = new Locale[availableLocaleListCount]; |
| } |
| if (availableLocaleList == NULL) { |
| availableLocaleListCount= 0; |
| } |
| for (int32_t locCount=availableLocaleListCount-1; locCount>=0; --locCount) { |
| availableLocaleList[locCount].setFromPOSIXID(uloc_getAvailable(locCount)); |
| } |
| ucln_common_registerCleanup(UCLN_COMMON_LOCALE_AVAILABLE, locale_available_cleanup); |
| } |
| |
| const Locale* U_EXPORT2 |
| Locale::getAvailableLocales(int32_t& count) |
| { |
| umtx_initOnce(gInitOnceLocale, &locale_available_init); |
| count = availableLocaleListCount; |
| return availableLocaleList; |
| } |
| |
| |
| U_NAMESPACE_END |
| |
| // C API ------------------------------------------------------------------- *** |
| |
| U_NAMESPACE_USE |
| |
| /* ### Constants **************************************************/ |
| |
| namespace { |
| |
| // Enough capacity for the two lists in the res_index.res file |
| const char** gAvailableLocaleNames[2] = {}; |
| int32_t gAvailableLocaleCounts[2] = {}; |
| icu::UInitOnce ginstalledLocalesInitOnce = U_INITONCE_INITIALIZER; |
| |
| class AvailableLocalesSink : public ResourceSink { |
| public: |
| void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) U_OVERRIDE { |
| ResourceTable resIndexTable = value.getTable(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| for (int32_t i = 0; resIndexTable.getKeyAndValue(i, key, value); ++i) { |
| ULocAvailableType type; |
| if (uprv_strcmp(key, "InstalledLocales") == 0) { |
| type = ULOC_AVAILABLE_DEFAULT; |
| } else if (uprv_strcmp(key, "AliasLocales") == 0) { |
| type = ULOC_AVAILABLE_ONLY_LEGACY_ALIASES; |
| } else { |
| // CLDRVersion, etc. |
| continue; |
| } |
| ResourceTable availableLocalesTable = value.getTable(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| gAvailableLocaleCounts[type] = availableLocalesTable.getSize(); |
| gAvailableLocaleNames[type] = static_cast<const char**>( |
| uprv_malloc(gAvailableLocaleCounts[type] * sizeof(const char*))); |
| if (gAvailableLocaleNames[type] == nullptr) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| for (int32_t j = 0; availableLocalesTable.getKeyAndValue(j, key, value); ++j) { |
| gAvailableLocaleNames[type][j] = key; |
| } |
| } |
| } |
| }; |
| |
| class AvailableLocalesStringEnumeration : public StringEnumeration { |
| public: |
| AvailableLocalesStringEnumeration(ULocAvailableType type) : fType(type) { |
| } |
| |
| const char* next(int32_t *resultLength, UErrorCode&) override { |
| ULocAvailableType actualType = fType; |
| int32_t actualIndex = fIndex++; |
| |
| // If the "combined" list was requested, resolve that now |
| if (fType == ULOC_AVAILABLE_WITH_LEGACY_ALIASES) { |
| int32_t defaultLocalesCount = gAvailableLocaleCounts[ULOC_AVAILABLE_DEFAULT]; |
| if (actualIndex < defaultLocalesCount) { |
| actualType = ULOC_AVAILABLE_DEFAULT; |
| } else { |
| actualIndex -= defaultLocalesCount; |
| actualType = ULOC_AVAILABLE_ONLY_LEGACY_ALIASES; |
| } |
| } |
| |
| // Return the requested string |
| int32_t count = gAvailableLocaleCounts[actualType]; |
| const char* result; |
| if (actualIndex < count) { |
| result = gAvailableLocaleNames[actualType][actualIndex]; |
| if (resultLength != nullptr) { |
| *resultLength = static_cast<int32_t>(uprv_strlen(result)); |
| } |
| } else { |
| result = nullptr; |
| if (resultLength != nullptr) { |
| *resultLength = 0; |
| } |
| } |
| return result; |
| } |
| |
| void reset(UErrorCode&) override { |
| fIndex = 0; |
| } |
| |
| int32_t count(UErrorCode&) const override { |
| if (fType == ULOC_AVAILABLE_WITH_LEGACY_ALIASES) { |
| return gAvailableLocaleCounts[ULOC_AVAILABLE_DEFAULT] |
| + gAvailableLocaleCounts[ULOC_AVAILABLE_ONLY_LEGACY_ALIASES]; |
| } else { |
| return gAvailableLocaleCounts[fType]; |
| } |
| } |
| |
| private: |
| ULocAvailableType fType; |
| int32_t fIndex = 0; |
| }; |
| |
| /* ### Get available **************************************************/ |
| |
| static UBool U_CALLCONV uloc_cleanup(void) { |
| for (int32_t i = 0; i < UPRV_LENGTHOF(gAvailableLocaleNames); i++) { |
| uprv_free(gAvailableLocaleNames[i]); |
| gAvailableLocaleNames[i] = nullptr; |
| gAvailableLocaleCounts[i] = 0; |
| } |
| ginstalledLocalesInitOnce.reset(); |
| return TRUE; |
| } |
| |
| // Load Installed Locales. This function will be called exactly once |
| // via the initOnce mechanism. |
| |
| static void U_CALLCONV loadInstalledLocales(UErrorCode& status) { |
| ucln_common_registerCleanup(UCLN_COMMON_ULOC, uloc_cleanup); |
| |
| icu::LocalUResourceBundlePointer rb(ures_openDirect(NULL, "res_index", &status)); |
| AvailableLocalesSink sink; |
| ures_getAllItemsWithFallback(rb.getAlias(), "", sink, status); |
| } |
| |
| void _load_installedLocales(UErrorCode& status) { |
| umtx_initOnce(ginstalledLocalesInitOnce, &loadInstalledLocales, status); |
| } |
| |
| } // namespace |
| |
| U_CAPI const char* U_EXPORT2 |
| uloc_getAvailable(int32_t offset) { |
| icu::ErrorCode status; |
| _load_installedLocales(status); |
| if (status.isFailure()) { |
| return nullptr; |
| } |
| if (offset > gAvailableLocaleCounts[0]) { |
| // *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return nullptr; |
| } |
| return gAvailableLocaleNames[0][offset]; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_countAvailable() { |
| icu::ErrorCode status; |
| _load_installedLocales(status); |
| if (status.isFailure()) { |
| return 0; |
| } |
| return gAvailableLocaleCounts[0]; |
| } |
| |
| U_CAPI UEnumeration* U_EXPORT2 |
| uloc_openAvailableByType(ULocAvailableType type, UErrorCode* status) { |
| if (U_FAILURE(*status)) { |
| return nullptr; |
| } |
| if (type < 0 || type >= ULOC_AVAILABLE_COUNT) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return nullptr; |
| } |
| _load_installedLocales(*status); |
| if (U_FAILURE(*status)) { |
| return nullptr; |
| } |
| LocalPointer<AvailableLocalesStringEnumeration> result( |
| new AvailableLocalesStringEnumeration(type), *status); |
| if (U_FAILURE(*status)) { |
| return nullptr; |
| } |
| return uenum_openFromStringEnumeration(result.orphan(), status); |
| } |
| |
