tor-browser

locutil.cpp (8886B)

---

// © 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(static_cast<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 = static_cast<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