// © 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. */ #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 = nullptr; static int32_t availableLocaleListCount; static icu::UInitOnce gInitOnceLocale {}; namespace { UBool U_CALLCONV locale_available_cleanup() { if (availableLocaleList) { delete []availableLocaleList; availableLocaleList = nullptr; } availableLocaleListCount = 0; gInitOnceLocale.reset(); return true; } } // namespace 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 == nullptr) { 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 {}; class AvailableLocalesSink : public ResourceSink { public: void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) override { if (U_FAILURE(status)) { return; } 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 &status) override { if (U_FAILURE(status)) { return nullptr; } 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 &status) override { if (U_FAILURE(status)) { return; } fIndex = 0; } int32_t count(UErrorCode &status) const override { if (U_FAILURE(status)) { return 0; } 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 **************************************************/ UBool U_CALLCONV uloc_cleanup() { 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. void U_CALLCONV loadInstalledLocales(UErrorCode& status) { ucln_common_registerCleanup(UCLN_COMMON_ULOC, uloc_cleanup); icu::LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "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); }