276 lines
8.7 KiB
C++
276 lines
8.7 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2002-2014, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*******************************************************************************
|
|
*/
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_SERVICE || !UCONFIG_NO_TRANSLITERATION
|
|
|
|
#include "unicode/resbund.h"
|
|
#include "unicode/uenum.h"
|
|
#include "cmemory.h"
|
|
#include "ustrfmt.h"
|
|
#include "locutil.h"
|
|
#include "charstr.h"
|
|
#include "ucln_cmn.h"
|
|
#include "uassert.h"
|
|
#include "umutex.h"
|
|
|
|
// see LocaleUtility::getAvailableLocaleNames
|
|
static icu::UInitOnce LocaleUtilityInitOnce {};
|
|
static icu::Hashtable * LocaleUtility_cache = nullptr;
|
|
|
|
#define UNDERSCORE_CHAR ((char16_t)0x005f)
|
|
#define AT_SIGN_CHAR ((char16_t)64)
|
|
#define PERIOD_CHAR ((char16_t)46)
|
|
|
|
/*
|
|
******************************************************************
|
|
*/
|
|
|
|
/**
|
|
* Release all static memory held by Locale Utility.
|
|
*/
|
|
U_CDECL_BEGIN
|
|
static UBool U_CALLCONV service_cleanup() {
|
|
if (LocaleUtility_cache) {
|
|
delete LocaleUtility_cache;
|
|
LocaleUtility_cache = nullptr;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
static void U_CALLCONV locale_utility_init(UErrorCode &status) {
|
|
using namespace icu;
|
|
U_ASSERT(LocaleUtility_cache == nullptr);
|
|
ucln_common_registerCleanup(UCLN_COMMON_SERVICE, service_cleanup);
|
|
LocaleUtility_cache = new Hashtable(status);
|
|
if (U_FAILURE(status)) {
|
|
delete LocaleUtility_cache;
|
|
LocaleUtility_cache = nullptr;
|
|
return;
|
|
}
|
|
if (LocaleUtility_cache == nullptr) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
LocaleUtility_cache->setValueDeleter(uhash_deleteHashtable);
|
|
}
|
|
|
|
U_CDECL_END
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
UnicodeString&
|
|
LocaleUtility::canonicalLocaleString(const UnicodeString* id, UnicodeString& result)
|
|
{
|
|
if (id == nullptr) {
|
|
result.setToBogus();
|
|
} else {
|
|
// Fix case only (no other changes) up to the first '@' or '.' or
|
|
// end of string, whichever comes first. In 3.0 I changed this to
|
|
// stop at first '@' or '.'. It used to run out to the end of
|
|
// string. My fix makes the tests pass but is probably
|
|
// structurally incorrect. See below. [alan 3.0]
|
|
|
|
// TODO: Doug, you might want to revise this...
|
|
result = *id;
|
|
int32_t i = 0;
|
|
int32_t end = result.indexOf(AT_SIGN_CHAR);
|
|
int32_t n = result.indexOf(PERIOD_CHAR);
|
|
if (n >= 0 && n < end) {
|
|
end = n;
|
|
}
|
|
if (end < 0) {
|
|
end = result.length();
|
|
}
|
|
n = result.indexOf(UNDERSCORE_CHAR);
|
|
if (n < 0) {
|
|
n = end;
|
|
}
|
|
for (; i < n; ++i) {
|
|
char16_t c = result.charAt(i);
|
|
if (c >= 0x0041 && c <= 0x005a) {
|
|
c += 0x20;
|
|
result.setCharAt(i, c);
|
|
}
|
|
}
|
|
for (n = end; i < n; ++i) {
|
|
char16_t c = result.charAt(i);
|
|
if (c >= 0x0061 && c <= 0x007a) {
|
|
c -= 0x20;
|
|
result.setCharAt(i, c);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
|
|
#if 0
|
|
// This code does a proper full level 2 canonicalization of id.
|
|
// It's nasty to go from char16_t to char to char to char16_t -- but
|
|
// that's what you have to do to use the uloc_canonicalize
|
|
// function on UnicodeStrings.
|
|
|
|
// I ended up doing the alternate fix (see above) not for
|
|
// performance reasons, although performance will certainly be
|
|
// better, but because doing a full level 2 canonicalization
|
|
// causes some tests to fail. [alan 3.0]
|
|
|
|
// TODO: Doug, you might want to revisit this...
|
|
result.setToBogus();
|
|
if (id != 0) {
|
|
int32_t buflen = id->length() + 8; // space for NUL
|
|
char* buf = (char*) uprv_malloc(buflen);
|
|
char* canon = (buf == 0) ? 0 : (char*) uprv_malloc(buflen);
|
|
if (buf != 0 && canon != 0) {
|
|
U_ASSERT(id->extract(0, INT32_MAX, buf, buflen) < buflen);
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
uloc_canonicalize(buf, canon, buflen, &ec);
|
|
if (U_SUCCESS(ec)) {
|
|
result = UnicodeString(canon);
|
|
}
|
|
}
|
|
uprv_free(buf);
|
|
uprv_free(canon);
|
|
}
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
Locale&
|
|
LocaleUtility::initLocaleFromName(const UnicodeString& id, Locale& result)
|
|
{
|
|
if (id.isBogus()) {
|
|
result.setToBogus();
|
|
} else {
|
|
/*
|
|
* We need to convert from a UnicodeString to char * in order to
|
|
* create a Locale.
|
|
*
|
|
* Problem: Locale ID strings may contain '@' which is a variant
|
|
* character and cannot be handled by invariant-character conversion.
|
|
*
|
|
* Hack: Since ICU code can handle locale IDs with multiple encodings
|
|
* of '@' (at least for EBCDIC; it's not known to be a problem for
|
|
* ASCII-based systems),
|
|
* we use regular invariant-character conversion for everything else
|
|
* and manually convert U+0040 into a compiler-char-constant '@'.
|
|
* While this compilation-time constant may not match the runtime
|
|
* encoding of '@', it should be one of the encodings which ICU
|
|
* recognizes.
|
|
*
|
|
* There should be only at most one '@' in a locale ID.
|
|
*/
|
|
CharString buffer;
|
|
int32_t prev, i;
|
|
prev = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
do {
|
|
i = id.indexOf((char16_t)0x40, prev);
|
|
if(i < 0) {
|
|
// no @ between prev and the rest of the string
|
|
buffer.appendInvariantChars(id.tempSubString(prev), status);
|
|
break; // done
|
|
} else {
|
|
// normal invariant-character conversion for text between @s
|
|
buffer.appendInvariantChars(id.tempSubString(prev, i - prev), status);
|
|
// manually "convert" U+0040 at id[i] into '@' at buffer[i]
|
|
buffer.append('@', status);
|
|
prev = i + 1;
|
|
}
|
|
} while (U_SUCCESS(status));
|
|
if (U_FAILURE(status)) {
|
|
result.setToBogus();
|
|
} else {
|
|
result = Locale::createFromName(buffer.data());
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
UnicodeString&
|
|
LocaleUtility::initNameFromLocale(const Locale& locale, UnicodeString& result)
|
|
{
|
|
if (locale.isBogus()) {
|
|
result.setToBogus();
|
|
} else {
|
|
result.append(UnicodeString(locale.getName(), -1, US_INV));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const Hashtable*
|
|
LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID)
|
|
{
|
|
// LocaleUtility_cache is a hash-of-hashes. The top-level keys
|
|
// are path strings ('bundleID') passed to
|
|
// ures_openAvailableLocales. The top-level values are
|
|
// second-level hashes. The second-level keys are result strings
|
|
// from ures_openAvailableLocales. The second-level values are
|
|
// garbage ((void*)1 or other random pointer).
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
umtx_initOnce(LocaleUtilityInitOnce, locale_utility_init, status);
|
|
Hashtable *cache = LocaleUtility_cache;
|
|
if (cache == nullptr) {
|
|
// Catastrophic failure.
|
|
return nullptr;
|
|
}
|
|
|
|
Hashtable* htp;
|
|
umtx_lock(nullptr);
|
|
htp = (Hashtable*) cache->get(bundleID);
|
|
umtx_unlock(nullptr);
|
|
|
|
if (htp == nullptr) {
|
|
htp = new Hashtable(status);
|
|
if (htp && U_SUCCESS(status)) {
|
|
CharString cbundleID;
|
|
cbundleID.appendInvariantChars(bundleID, status);
|
|
const char* path = cbundleID.isEmpty() ? nullptr : cbundleID.data();
|
|
icu::LocalUEnumerationPointer uenum(ures_openAvailableLocales(path, &status));
|
|
for (;;) {
|
|
const char16_t* id = uenum_unext(uenum.getAlias(), nullptr, &status);
|
|
if (id == nullptr) {
|
|
break;
|
|
}
|
|
htp->put(UnicodeString(id), (void*)htp, status);
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
delete htp;
|
|
return nullptr;
|
|
}
|
|
umtx_lock(nullptr);
|
|
Hashtable *t = static_cast<Hashtable *>(cache->get(bundleID));
|
|
if (t != nullptr) {
|
|
// Another thread raced through this code, creating the cache entry first.
|
|
// Discard ours and return theirs.
|
|
umtx_unlock(nullptr);
|
|
delete htp;
|
|
htp = t;
|
|
} else {
|
|
cache->put(bundleID, (void*)htp, status);
|
|
umtx_unlock(nullptr);
|
|
}
|
|
}
|
|
}
|
|
return htp;
|
|
}
|
|
|
|
bool
|
|
LocaleUtility::isFallbackOf(const UnicodeString& root, const UnicodeString& child)
|
|
{
|
|
return child.indexOf(root) == 0 &&
|
|
(child.length() == root.length() ||
|
|
child.charAt(root.length()) == UNDERSCORE_CHAR);
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
/* !UCONFIG_NO_SERVICE */
|
|
#endif
|