../deps/icu-small/source/common/locid.cpp

Bug Summary

File:	out/../deps/icu-small/source/common/locid.cpp
Warning:	line 2390, column 5 Returning null reference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name locid.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/locid.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
**********************************************************************
*   Copyright (C) 1997-2016, International Business Machines
*   Corporation and others.  All Rights Reserved.
**********************************************************************
8*
9* File locid.cpp
10*
11* Created by: Richard Gillam
12*
13* Modification History:
14*
15*   Date        Name        Description
16*   02/11/97    aliu        Changed gLocPath to fgDataDirectory and added
17*                           methods to get and set it.
18*   04/02/97    aliu        Made operator!= inline; fixed return value
19*                           of getName().
20*   04/15/97    aliu        Cleanup for AIX/Win32.
21*   04/24/97    aliu        Numerous changes per code review.
22*   08/18/98    stephen     Changed getDisplayName()
23*                           Added SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE
24*                           Added getISOCountries(), getISOLanguages(),
25*                           getLanguagesForCountry()
26*   03/16/99    bertrand    rehaul.
27*   07/21/99    stephen     Added U_CFUNC setDefault
28*   11/09/99    weiv        Added const char * getName() const;
29*   04/12/00    srl         removing unicodestring api's and cached hash code
30*   08/10/01    grhoten     Change the static Locales to accessor functions
31******************************************************************************
32*/

34#include <utility>

36#include "unicode/bytestream.h"
37#include "unicode/locid.h"
38#include "unicode/localebuilder.h"
39#include "unicode/strenum.h"
40#include "unicode/stringpiece.h"
41#include "unicode/uloc.h"
42#include "unicode/ures.h"

44#include "bytesinkutil.h"
45#include "charstr.h"
46#include "charstrmap.h"
47#include "cmemory.h"
48#include "cstring.h"
49#include "mutex.h"
50#include "putilimp.h"
51#include "uassert.h"
52#include "ucln_cmn.h"
53#include "uhash.h"
54#include "ulocimp.h"
55#include "umutex.h"
56#include "uniquecharstr.h"
57#include "ustr_imp.h"
58#include "uvector.h"

60U_CDECL_BEGINextern "C" {
61static UBool U_CALLCONV locale_cleanup(void);
62U_CDECL_END}

64U_NAMESPACE_BEGINnamespace icu_71 {

66static Locale   *gLocaleCache = NULL__null;
67static UInitOnce gLocaleCacheInitOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};

69// gDefaultLocaleMutex protects all access to gDefaultLocalesHashT and gDefaultLocale.
70static UMutex gDefaultLocaleMutex;
71static UHashtable *gDefaultLocalesHashT = NULL__null;
72static Locale *gDefaultLocale = NULL__null;

74/**
* \def ULOC_STRING_LIMIT
* strings beyond this value crash in CharString
*/
78#define ULOC_STRING_LIMIT357913941 357913941

80U_NAMESPACE_END}

82typedef enum ELocalePos {
  eENGLISH,
  eFRENCH,
  eGERMAN,
  eITALIAN,
  eJAPANESE,
  eKOREAN,
  eCHINESE,

  eFRANCE,
  eGERMANY,
  eITALY,
  eJAPAN,
  eKOREA,
  eCHINA,      /* Alias for PRC */
  eTAIWAN,
  eUK,
  eUS,
  eCANADA,
  eCANADA_FRENCH,
  eROOT,


  //eDEFAULT,
  eMAX_LOCALES
107} ELocalePos;

109U_CDECL_BEGINextern "C" {
110//
111// Deleter function for Locales owned by the default Locale hash table/
112//
113static void U_CALLCONV
114deleteLocale(void *obj) {
  delete (icu::Locale *) obj;
116}

118static UBool U_CALLCONV locale_cleanup(void)
119{
  U_NAMESPACE_USEusing namespace icu_71;

  delete [] gLocaleCache;
  gLocaleCache = NULL__null;
  gLocaleCacheInitOnce.reset();

  if (gDefaultLocalesHashT) {
      uhash_closeuhash_close_71(gDefaultLocalesHashT);   // Automatically deletes all elements, using deleter func.
      gDefaultLocalesHashT = NULL__null;
  }
  gDefaultLocale = NULL__null;
  return TRUE1;
132}


135static void U_CALLCONV locale_init(UErrorCode &status) {
  U_NAMESPACE_USEusing namespace icu_71;

  U_ASSERT(gLocaleCache == NULL)(void)0;
  gLocaleCache = new Locale[(int)eMAX_LOCALES];
  if (gLocaleCache == NULL__null) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  ucln_common_registerCleanupucln_common_registerCleanup_71(UCLN_COMMON_LOCALE, locale_cleanup);
  gLocaleCache[eROOT]          = Locale("");
  gLocaleCache[eENGLISH]       = Locale("en");
  gLocaleCache[eFRENCH]        = Locale("fr");
  gLocaleCache[eGERMAN]        = Locale("de");
  gLocaleCache[eITALIAN]       = Locale("it");
  gLocaleCache[eJAPANESE]      = Locale("ja");
  gLocaleCache[eKOREAN]        = Locale("ko");
  gLocaleCache[eCHINESE]       = Locale("zh");
  gLocaleCache[eFRANCE]        = Locale("fr", "FR");
  gLocaleCache[eGERMANY]       = Locale("de", "DE");
  gLocaleCache[eITALY]         = Locale("it", "IT");
  gLocaleCache[eJAPAN]         = Locale("ja", "JP");
  gLocaleCache[eKOREA]         = Locale("ko", "KR");
  gLocaleCache[eCHINA]         = Locale("zh", "CN");
  gLocaleCache[eTAIWAN]        = Locale("zh", "TW");
  gLocaleCache[eUK]            = Locale("en", "GB");
  gLocaleCache[eUS]            = Locale("en", "US");
  gLocaleCache[eCANADA]        = Locale("en", "CA");
  gLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA");
164}

166U_CDECL_END}

168U_NAMESPACE_BEGINnamespace icu_71 {

170Locale *locale_set_default_internal(const char *id, UErrorCode& status) {
  // Synchronize this entire function.
  Mutex lock(&gDefaultLocaleMutex);

  UBool canonicalize = FALSE0;

  // If given a NULL string for the locale id, grab the default
  //   name from the system.
  //   (Different from most other locale APIs, where a null name means use
  //    the current ICU default locale.)
  if (id == NULL__null) {
      id = uprv_getDefaultLocaleIDuprv_getDefaultLocaleID_71();   // This function not thread safe? TODO: verify.
      canonicalize = TRUE1; // always canonicalize host ID
  }

  CharString localeNameBuf;
  {
      CharStringByteSink sink(&localeNameBuf);
      if (canonicalize) {
          ulocimp_canonicalizeulocimp_canonicalize_71(id, sink, &status);
      } else {
          ulocimp_getNameulocimp_getName_71(id, sink, &status);
      }
  }

  if (U_FAILURE(status)) {
      return gDefaultLocale;
  }

  if (gDefaultLocalesHashT == NULL__null) {
      gDefaultLocalesHashT = uhash_openuhash_open_71(uhash_hashCharsuhash_hashChars_71, uhash_compareCharsuhash_compareChars_71, NULL__null, &status);
      if (U_FAILURE(status)) {
          return gDefaultLocale;
      }
      uhash_setValueDeleteruhash_setValueDeleter_71(gDefaultLocalesHashT, deleteLocale);
      ucln_common_registerCleanupucln_common_registerCleanup_71(UCLN_COMMON_LOCALE, locale_cleanup);
  }

  Locale *newDefault = (Locale *)uhash_getuhash_get_71(gDefaultLocalesHashT, localeNameBuf.data());
  if (newDefault == NULL__null) {
      newDefault = new Locale(Locale::eBOGUS);
      if (newDefault == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return gDefaultLocale;
      }
      newDefault->init(localeNameBuf.data(), FALSE0);
      uhash_putuhash_put_71(gDefaultLocalesHashT, (char*) newDefault->getName(), newDefault, &status);
      if (U_FAILURE(status)) {
          return gDefaultLocale;
      }
  }
  gDefaultLocale = newDefault;
  return gDefaultLocale;
223}

225U_NAMESPACE_END}

227/* sfb 07/21/99 */
228U_CFUNCextern "C" void
229locale_set_defaultlocale_set_default_71(const char *id)
230{
  U_NAMESPACE_USEusing namespace icu_71;
  UErrorCode status = U_ZERO_ERROR;
  locale_set_default_internal(id, status);
234}
235/* end */

237U_CFUNCextern "C" const char *
238locale_get_defaultlocale_get_default_71(void)
239{
  U_NAMESPACE_USEusing namespace icu_71;
  return Locale::getDefault().getName();
242}


245U_NAMESPACE_BEGINnamespace icu_71 {

247UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)UClassID Locale::getStaticClassID() { static char classID = 0
; return (UClassID)&classID; } UClassID Locale::getDynamicClassID
() const { return Locale::getStaticClassID(); }

249/*Character separating the posix id fields*/
250// '_'
251// In the platform codepage.
252#define SEP_CHAR'_' '_'
253#define NULL_CHAR'\0' '\0'

255Locale::~Locale()
256{
  if ((baseName != fullName) && (baseName != fullNameBuffer)) {
      uprv_freeuprv_free_71(baseName);
  }
  baseName = NULL__null;
  /*if fullName is on the heap, we free it*/
  if (fullName != fullNameBuffer)
  {
      uprv_freeuprv_free_71(fullName);
      fullName = NULL__null;
  }
267}

269Locale::Locale()
  : UObject(), fullName(fullNameBuffer), baseName(NULL__null)
271{
  init(NULL__null, FALSE0);
273}

275/*
* Internal constructor to allow construction of a locale object with
*   NO side effects.   (Default constructor tries to get
*   the default locale.)
*/
280Locale::Locale(Locale::ELocaleType)
  : UObject(), fullName(fullNameBuffer), baseName(NULL__null)
282{
  setToBogus();
284}


287Locale::Locale( const   char * newLanguage,
              const   char * newCountry,
              const   char * newVariant,
              const   char * newKeywords)
  : UObject(), fullName(fullNameBuffer), baseName(NULL__null)
292{
  if( (newLanguage==NULL__null) && (newCountry == NULL__null) && (newVariant == NULL__null) )
  {
      init(NULL__null, FALSE0); /* shortcut */
  }
  else
  {
      UErrorCode status = U_ZERO_ERROR;
      int32_t lsize = 0;
      int32_t csize = 0;
      int32_t vsize = 0;
      int32_t ksize = 0;

      // Check the sizes of the input strings.

      // Language
      if ( newLanguage != NULL__null )
      {
          lsize = (int32_t)uprv_strlen(newLanguage):: strlen(newLanguage);
          if ( lsize < 0 || lsize > ULOC_STRING_LIMIT357913941 ) { // int32 wrap
              setToBogus();
              return;
          }
      }

      CharString togo(newLanguage, lsize, status); // start with newLanguage

      // _Country
      if ( newCountry != NULL__null )
      {
          csize = (int32_t)uprv_strlen(newCountry):: strlen(newCountry);
          if ( csize < 0 || csize > ULOC_STRING_LIMIT357913941 ) { // int32 wrap
              setToBogus();
              return;
          }
      }

      // _Variant
      if ( newVariant != NULL__null )
      {
          // remove leading _'s
          while(newVariant[0] == SEP_CHAR'_')
          {
              newVariant++;
          }

          // remove trailing _'s
          vsize = (int32_t)uprv_strlen(newVariant):: strlen(newVariant);
          if ( vsize < 0 || vsize > ULOC_STRING_LIMIT357913941 ) { // int32 wrap
              setToBogus();
              return;
          }
          while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR'_') )
          {
              vsize--;
          }
      }

      if ( newKeywords != NULL__null)
      {
          ksize = (int32_t)uprv_strlen(newKeywords):: strlen(newKeywords);
          if ( ksize < 0 || ksize > ULOC_STRING_LIMIT357913941 ) {
            setToBogus();
            return;
          }
      }

      // We've checked the input sizes, now build up the full locale string..

      // newLanguage is already copied

      if ( ( vsize != 0 ) || (csize != 0) )  // at least:  __v
      {                                      //            ^
          togo.append(SEP_CHAR'_', status);
      }

      if ( csize != 0 )
      {
          togo.append(newCountry, status);
      }

      if ( vsize != 0)
      {
          togo.append(SEP_CHAR'_', status)
              .append(newVariant, vsize, status);
      }

      if ( ksize != 0)
      {
          if (uprv_strchr(newKeywords, '='):: strchr(newKeywords, '=')) {
              togo.append('@', status); /* keyword parsing */
          }
          else {
              togo.append('_', status); /* Variant parsing with a script */
              if ( vsize == 0) {
                  togo.append('_', status); /* No country found */
              }
          }
          togo.append(newKeywords, status);
      }

      if (U_FAILURE(status)) {
          // Something went wrong with appending, etc.
          setToBogus();
          return;
      }
      // Parse it, because for example 'language' might really be a complete
      // string.
      init(togo.data(), FALSE0);
  }
402}

404Locale::Locale(const Locale &other)
  : UObject(other), fullName(fullNameBuffer), baseName(NULL__null)
406{
  *this = other;
408}

410Locale::Locale(Locale&& other) U_NOEXCEPTnoexcept
  : UObject(other), fullName(fullNameBuffer), baseName(fullName) {
*this = std::move(other);
413}

415Locale& Locale::operator=(const Locale& other) {
  if (this == &other) {
      return *this;
  }

  setToBogus();

  if (other.fullName == other.fullNameBuffer) {
      uprv_strcpy(fullNameBuffer, other.fullNameBuffer):: strcpy(fullNameBuffer, other.fullNameBuffer);
  } else if (other.fullName == nullptr) {
      fullName = nullptr;
  } else {
      fullName = uprv_strdupuprv_strdup_71(other.fullName);
      if (fullName == nullptr) return *this;
  }

  if (other.baseName == other.fullName) {
      baseName = fullName;
  } else if (other.baseName != nullptr) {
      baseName = uprv_strdupuprv_strdup_71(other.baseName);
      if (baseName == nullptr) return *this;
  }

  uprv_strcpy(language, other.language):: strcpy(language, other.language);
  uprv_strcpy(script, other.script):: strcpy(script, other.script);
  uprv_strcpy(country, other.country):: strcpy(country, other.country);

  variantBegin = other.variantBegin;
  fIsBogus = other.fIsBogus;

  return *this;
446}

448Locale& Locale::operator=(Locale&& other) U_NOEXCEPTnoexcept {
  if ((baseName != fullName) && (baseName != fullNameBuffer)) uprv_freeuprv_free_71(baseName);
  if (fullName != fullNameBuffer) uprv_freeuprv_free_71(fullName);

  if (other.fullName == other.fullNameBuffer || other.baseName == other.fullNameBuffer) {
      uprv_strcpy(fullNameBuffer, other.fullNameBuffer):: strcpy(fullNameBuffer, other.fullNameBuffer);
  }
  if (other.fullName == other.fullNameBuffer) {
      fullName = fullNameBuffer;
  } else {
      fullName = other.fullName;
  }

  if (other.baseName == other.fullNameBuffer) {
      baseName = fullNameBuffer;
  } else if (other.baseName == other.fullName) {
      baseName = fullName;
  } else {
      baseName = other.baseName;
  }

  uprv_strcpy(language, other.language):: strcpy(language, other.language);
  uprv_strcpy(script, other.script):: strcpy(script, other.script);
  uprv_strcpy(country, other.country):: strcpy(country, other.country);

  variantBegin = other.variantBegin;
  fIsBogus = other.fIsBogus;

  other.baseName = other.fullName = other.fullNameBuffer;

  return *this;
479}

481Locale *
482Locale::clone() const {
  return new Locale(*this);
484}

486bool
487Locale::operator==( const   Locale& other) const
488{
  return (uprv_strcmp(other.fullName, fullName):: strcmp(other.fullName, fullName) == 0);
490}

492namespace {

494UInitOnce gKnownCanonicalizedInitOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};
495UHashtable *gKnownCanonicalized = nullptr;

497static const char* const KNOWN_CANONICALIZED[] = {
  "c",
  // Commonly used locales known are already canonicalized
  "af", "af_ZA", "am", "am_ET", "ar", "ar_001", "as", "as_IN", "az", "az_AZ",
  "be", "be_BY", "bg", "bg_BG", "bn", "bn_IN", "bs", "bs_BA", "ca", "ca_ES",
  "cs", "cs_CZ", "cy", "cy_GB", "da", "da_DK", "de", "de_DE", "el", "el_GR",
  "en", "en_GB", "en_US", "es", "es_419", "es_ES", "et", "et_EE", "eu",
  "eu_ES", "fa", "fa_IR", "fi", "fi_FI", "fil", "fil_PH", "fr", "fr_FR",
  "ga", "ga_IE", "gl", "gl_ES", "gu", "gu_IN", "he", "he_IL", "hi", "hi_IN",
  "hr", "hr_HR", "hu", "hu_HU", "hy", "hy_AM", "id", "id_ID", "is", "is_IS",
  "it", "it_IT", "ja", "ja_JP", "jv", "jv_ID", "ka", "ka_GE", "kk", "kk_KZ",
  "km", "km_KH", "kn", "kn_IN", "ko", "ko_KR", "ky", "ky_KG", "lo", "lo_LA",
  "lt", "lt_LT", "lv", "lv_LV", "mk", "mk_MK", "ml", "ml_IN", "mn", "mn_MN",
  "mr", "mr_IN", "ms", "ms_MY", "my", "my_MM", "nb", "nb_NO", "ne", "ne_NP",
  "nl", "nl_NL", "no", "or", "or_IN", "pa", "pa_IN", "pl", "pl_PL", "ps", "ps_AF",
  "pt", "pt_BR", "pt_PT", "ro", "ro_RO", "ru", "ru_RU", "sd", "sd_IN", "si",
  "si_LK", "sk", "sk_SK", "sl", "sl_SI", "so", "so_SO", "sq", "sq_AL", "sr",
  "sr_Cyrl_RS", "sr_Latn", "sr_RS", "sv", "sv_SE", "sw", "sw_TZ", "ta",
  "ta_IN", "te", "te_IN", "th", "th_TH", "tk", "tk_TM", "tr", "tr_TR", "uk",
  "uk_UA", "ur", "ur_PK", "uz", "uz_UZ", "vi", "vi_VN", "yue", "yue_Hant",
  "yue_Hant_HK", "yue_HK", "zh", "zh_CN", "zh_Hans", "zh_Hans_CN", "zh_Hant",
  "zh_Hant_TW", "zh_TW", "zu", "zu_ZA"
519};

521static UBool U_CALLCONV cleanupKnownCanonicalized() {
  gKnownCanonicalizedInitOnce.reset();
  if (gKnownCanonicalized) { uhash_closeuhash_close_71(gKnownCanonicalized); }
  return TRUE1;
525}

527static void U_CALLCONV loadKnownCanonicalized(UErrorCode &status) {
  ucln_common_registerCleanupucln_common_registerCleanup_71(UCLN_COMMON_LOCALE_KNOWN_CANONICALIZED,
                              cleanupKnownCanonicalized);
  LocalUHashtablePointer newKnownCanonicalizedMap(
      uhash_openuhash_open_71(uhash_hashCharsuhash_hashChars_71, uhash_compareCharsuhash_compareChars_71, nullptr, &status));
  for (int32_t i = 0;
          U_SUCCESS(status) && i < UPRV_LENGTHOF(KNOWN_CANONICALIZED)(int32_t)(sizeof(KNOWN_CANONICALIZED)/sizeof((KNOWN_CANONICALIZED
)[0]));
          i++) {
      uhash_putiuhash_puti_71(newKnownCanonicalizedMap.getAlias(),
                 (void*)KNOWN_CANONICALIZED[i],
                 1, &status);
  }
  if (U_FAILURE(status)) {
      return;
  }

  gKnownCanonicalized = newKnownCanonicalizedMap.orphan();
544}

546class AliasData;

548/**
* A Builder class to build the alias data.
*/
551class AliasDataBuilder {
552public:
  AliasDataBuilder() {
  }

  // Build the AliasData from resource.
  AliasData* build(UErrorCode &status);

559private:
  void readAlias(UResourceBundle* alias,
                 UniqueCharStrings* strings,
                 LocalMemory<const char*>& types,
                 LocalMemory<int32_t>& replacementIndexes,
                 int32_t &length,
                 void (*checkType)(const char* type),
                 void (*checkReplacement)(const UnicodeString& replacement),
                 UErrorCode &status);

  // Read the languageAlias data from alias to
  // strings+types+replacementIndexes
  // The number of record will be stored into length.
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement script.
  void readLanguageAlias(UResourceBundle* alias,
                         UniqueCharStrings* strings,
                         LocalMemory<const char*>& types,
                         LocalMemory<int32_t>& replacementIndexes,
                         int32_t &length,
                         UErrorCode &status);

  // Read the scriptAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement script.
  void readScriptAlias(UResourceBundle* alias,
                       UniqueCharStrings* strings,
                       LocalMemory<const char*>& types,
                       LocalMemory<int32_t>& replacementIndexes,
                       int32_t &length, UErrorCode &status);

  // Read the territoryAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement script.
  void readTerritoryAlias(UResourceBundle* alias,
                          UniqueCharStrings* strings,
                          LocalMemory<const char*>& types,
                          LocalMemory<int32_t>& replacementIndexes,
                          int32_t &length, UErrorCode &status);

  // Read the variantAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement variant.
  void readVariantAlias(UResourceBundle* alias,
                        UniqueCharStrings* strings,
                        LocalMemory<const char*>& types,
                        LocalMemory<int32_t>& replacementIndexes,
                        int32_t &length, UErrorCode &status);

  // Read the subdivisionAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement variant.
  void readSubdivisionAlias(UResourceBundle* alias,
                        UniqueCharStrings* strings,
                        LocalMemory<const char*>& types,
                        LocalMemory<int32_t>& replacementIndexes,
                        int32_t &length, UErrorCode &status);
625};

627/**
* A class to hold the Alias Data.
*/
630class AliasData : public UMemory {
631public:
  static const AliasData* singleton(UErrorCode& status) {
      if (U_FAILURE(status)) {
          // Do not get into loadData if the status already has error.
          return nullptr;
      }
      umtx_initOnce(AliasData::gInitOnce, &AliasData::loadData, status);
      return gSingleton;
  }

  const CharStringMap& languageMap() const { return language; }
  const CharStringMap& scriptMap() const { return script; }
  const CharStringMap& territoryMap() const { return territory; }
  const CharStringMap& variantMap() const { return variant; }
  const CharStringMap& subdivisionMap() const { return subdivision; }

  static void U_CALLCONV loadData(UErrorCode &status);
  static UBool U_CALLCONV cleanup();

  static UInitOnce gInitOnce;

652private:
  AliasData(CharStringMap languageMap,
            CharStringMap scriptMap,
            CharStringMap territoryMap,
            CharStringMap variantMap,
            CharStringMap subdivisionMap,
            CharString* strings)
      : language(std::move(languageMap)),
        script(std::move(scriptMap)),
        territory(std::move(territoryMap)),
        variant(std::move(variantMap)),
        subdivision(std::move(subdivisionMap)),
        strings(strings) {
  }

  ~AliasData() {
      delete strings;
  }

  static const AliasData* gSingleton;

  CharStringMap language;
  CharStringMap script;
  CharStringMap territory;
  CharStringMap variant;
  CharStringMap subdivision;
  CharString* strings;

  friend class AliasDataBuilder;
681};


684const AliasData* AliasData::gSingleton = nullptr;
685UInitOnce AliasData::gInitOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};

687UBool U_CALLCONV
688AliasData::cleanup()
689{
  gInitOnce.reset();
  delete gSingleton;
  return TRUE1;
693}

695void
696AliasDataBuilder::readAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      void (*checkType)(const char* type),
      void (*checkReplacement)(const UnicodeString& replacement),
      UErrorCode &status) {
  if (U_FAILURE(status)) {
      return;
  }
  length = ures_getSizeures_getSize_71(alias);
  const char** rawTypes = types.allocateInsteadAndCopy(length);
  if (rawTypes == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  int32_t* rawIndexes = replacementIndexes.allocateInsteadAndCopy(length);
  if (rawIndexes == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  int i = 0;
  while (ures_hasNextures_hasNext_71(alias)) {
      LocalUResourceBundlePointer res(
          ures_getNextResourceures_getNextResource_71(alias, nullptr, &status));
      const char* aliasFrom = ures_getKeyures_getKey_71(res.getAlias());
      UnicodeString aliasTo =
          ures_getUnicodeStringByKey(res.getAlias(), "replacement", &status);

      checkType(aliasFrom);
      checkReplacement(aliasTo);

      rawTypes[i] = aliasFrom;
      rawIndexes[i] = strings->add(aliasTo, status);
      i++;
  }
734}

736/**
* Read the languageAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement language.
*/
742void
743AliasDataBuilder::readLanguageAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
750{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
753#if U_DEBUG0
      [](const char* type) {
          // Assert the aliasFrom only contains the following possibilities
          // language_REGION_variant
          // language_REGION
          // language_variant
          // language
          // und_variant
          Locale test(type);
          // Assert no script in aliasFrom
          U_ASSERT(test.getScript()[0] == '\0')(void)0;
          // Assert when language is und, no REGION in aliasFrom.
          U_ASSERT(test.getLanguage()[0] != '\0' || test.getCountry()[0] == '\0')(void)0;
      },
767#else
      [](const char*) {},
769#endif
      [](const UnicodeString&) {}, status);
771}

773/**
* Read the scriptAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement script.
*/
779void
780AliasDataBuilder::readScriptAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
787{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
790#if U_DEBUG0
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) == 4)(void)0;
      },
      [](const UnicodeString& replacement) {
          U_ASSERT(replacement.length() == 4)(void)0;
      },
797#else
      [](const char*) {},
      [](const UnicodeString&) { },
800#endif
      status);
802}

804/**
* Read the territoryAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement regions.
*/
810void
811AliasDataBuilder::readTerritoryAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
818{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
821#if U_DEBUG0
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) == 2 || uprv_strlen(type) == 3)(void)0;
      },
825#else
      [](const char*) {},
827#endif
      [](const UnicodeString&) { },
      status);
830}

832/**
* Read the variantAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement variant.
*/
838void
839AliasDataBuilder::readVariantAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
846{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
849#if U_DEBUG0
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) >= 4 && uprv_strlen(type) <= 8)(void)0;
          U_ASSERT(uprv_strlen(type) != 4 ||(void)0
                   (type[0] >= '0' && type[0] <= '9'))(void)0;
      },
      [](const UnicodeString& replacement) {
          U_ASSERT(replacement.length() >= 4 && replacement.length() <= 8)(void)0;
          U_ASSERT(replacement.length() != 4 ||(void)0
                   (replacement.charAt(0) >= u'0' &&(void)0
                    replacement.charAt(0) <= u'9'))(void)0;
      },
861#else
      [](const char*) {},
      [](const UnicodeString&) { },
864#endif
      status);
866}

868/**
* Read the subdivisionAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement regions.
*/
874void
875AliasDataBuilder::readSubdivisionAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
882{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
885#if U_DEBUG0
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) >= 3 && uprv_strlen(type) <= 8)(void)0;
      },
889#else
      [](const char*) {},
891#endif
      [](const UnicodeString&) { },
      status);
894}

896/**
* Initializes the alias data from the ICU resource bundles. The alias data
* contains alias of language, country, script and variants.
*
* If the alias data has already loaded, then this method simply returns without
* doing anything meaningful.
*/
903void U_CALLCONV
904AliasData::loadData(UErrorCode &status)
905{
906#ifdef LOCALE_CANONICALIZATION_DEBUG
  UDate start = uprv_getRawUTCtimeuprv_getRawUTCtime_71();
908#endif  // LOCALE_CANONICALIZATION_DEBUG
  ucln_common_registerCleanupucln_common_registerCleanup_71(UCLN_COMMON_LOCALE_ALIAS, cleanup);
  AliasDataBuilder builder;
  gSingleton = builder.build(status);
912#ifdef LOCALE_CANONICALIZATION_DEBUG
  UDate end = uprv_getRawUTCtimeuprv_getRawUTCtime_71();
  printf("AliasData::loadData took total %f ms\n", end - start);
915#endif  // LOCALE_CANONICALIZATION_DEBUG
916}

918/**
* Build the alias data from resources.
*/
921AliasData*
922AliasDataBuilder::build(UErrorCode &status) {
  LocalUResourceBundlePointer metadata(
      ures_openDirectures_openDirect_71(nullptr, "metadata", &status));
  LocalUResourceBundlePointer metadataAlias(
      ures_getByKeyures_getByKey_71(metadata.getAlias(), "alias", nullptr, &status));
  LocalUResourceBundlePointer languageAlias(
      ures_getByKeyures_getByKey_71(metadataAlias.getAlias(), "language", nullptr, &status));
  LocalUResourceBundlePointer scriptAlias(
      ures_getByKeyures_getByKey_71(metadataAlias.getAlias(), "script", nullptr, &status));
  LocalUResourceBundlePointer territoryAlias(
      ures_getByKeyures_getByKey_71(metadataAlias.getAlias(), "territory", nullptr, &status));
  LocalUResourceBundlePointer variantAlias(
      ures_getByKeyures_getByKey_71(metadataAlias.getAlias(), "variant", nullptr, &status));
  LocalUResourceBundlePointer subdivisionAlias(
      ures_getByKeyures_getByKey_71(metadataAlias.getAlias(), "subdivision", nullptr, &status));

  if (U_FAILURE(status)) {
      return nullptr;
  }
  int32_t languagesLength = 0, scriptLength = 0, territoryLength = 0,
          variantLength = 0, subdivisionLength = 0;

  // Read the languageAlias into languageTypes, languageReplacementIndexes
  // and strings
  UniqueCharStrings strings(status);
  LocalMemory<const char*> languageTypes;
  LocalMemory<int32_t> languageReplacementIndexes;
  readLanguageAlias(languageAlias.getAlias(),
                    &strings,
                    languageTypes,
                    languageReplacementIndexes,
                    languagesLength,
                    status);

  // Read the scriptAlias into scriptTypes, scriptReplacementIndexes
  // and strings
  LocalMemory<const char*> scriptTypes;
  LocalMemory<int32_t> scriptReplacementIndexes;
  readScriptAlias(scriptAlias.getAlias(),
                  &strings,
                  scriptTypes,
                  scriptReplacementIndexes,
                  scriptLength,
                  status);

  // Read the territoryAlias into territoryTypes, territoryReplacementIndexes
  // and strings
  LocalMemory<const char*> territoryTypes;
  LocalMemory<int32_t> territoryReplacementIndexes;
  readTerritoryAlias(territoryAlias.getAlias(),
                     &strings,
                     territoryTypes,
                     territoryReplacementIndexes,
                     territoryLength, status);

  // Read the variantAlias into variantTypes, variantReplacementIndexes
  // and strings
  LocalMemory<const char*> variantTypes;
  LocalMemory<int32_t> variantReplacementIndexes;
  readVariantAlias(variantAlias.getAlias(),
                   &strings,
                   variantTypes,
                   variantReplacementIndexes,
                   variantLength, status);

  // Read the subdivisionAlias into subdivisionTypes, subdivisionReplacementIndexes
  // and strings
  LocalMemory<const char*> subdivisionTypes;
  LocalMemory<int32_t> subdivisionReplacementIndexes;
  readSubdivisionAlias(subdivisionAlias.getAlias(),
                       &strings,
                       subdivisionTypes,
                       subdivisionReplacementIndexes,
                       subdivisionLength, status);

  if (U_FAILURE(status)) {
      return nullptr;
  }

  // We can only use strings after freeze it.
  strings.freeze();

  // Build the languageMap from languageTypes & languageReplacementIndexes
  CharStringMap languageMap(490, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < languagesLength; i++) {
      languageMap.put(languageTypes[i],
                      strings.get(languageReplacementIndexes[i]),
                      status);
  }

  // Build the scriptMap from scriptTypes & scriptReplacementIndexes
  CharStringMap scriptMap(1, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < scriptLength; i++) {
      scriptMap.put(scriptTypes[i],
                    strings.get(scriptReplacementIndexes[i]),
                    status);
  }

  // Build the territoryMap from territoryTypes & territoryReplacementIndexes
  CharStringMap territoryMap(650, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < territoryLength; i++) {
      territoryMap.put(territoryTypes[i],
                       strings.get(territoryReplacementIndexes[i]),
                       status);
  }

  // Build the variantMap from variantTypes & variantReplacementIndexes.
  CharStringMap variantMap(2, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < variantLength; i++) {
      variantMap.put(variantTypes[i],
                     strings.get(variantReplacementIndexes[i]),
                     status);
  }

  // Build the subdivisionMap from subdivisionTypes & subdivisionReplacementIndexes.
  CharStringMap subdivisionMap(2, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < subdivisionLength; i++) {
      subdivisionMap.put(subdivisionTypes[i],
                     strings.get(subdivisionReplacementIndexes[i]),
                     status);
  }

  if (U_FAILURE(status)) {
      return nullptr;
  }

  // copy hashtables
  auto *data = new AliasData(
      std::move(languageMap),
      std::move(scriptMap),
      std::move(territoryMap),
      std::move(variantMap),
      std::move(subdivisionMap),
      strings.orphanCharStrings());

  if (data == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
  }
  return data;
1061}

1063/**
* A class that find the replacement values of locale fields by using AliasData.
*/
1066class AliasReplacer {
1067public:
  AliasReplacer(UErrorCode status) :
          language(nullptr), script(nullptr), region(nullptr),
          extensions(nullptr), variants(status),
          data(nullptr) {
  }
  ~AliasReplacer() {
  }

  // Check the fields inside locale, if need to replace fields,
  // place the the replaced locale ID in out and return true.
  // Otherwise return false for no replacement or error.
  bool replace(
      const Locale& locale, CharString& out, UErrorCode& status);

1082private:
  const char* language;
  const char* script;
  const char* region;
  const char* extensions;
  UVector variants;

  const AliasData* data;

  inline bool notEmpty(const char* str) {
      return str && str[0] != NULL_CHAR'\0';
  }

  /**
   * If replacement is neither null nor empty and input is either null or empty,
   * return replacement.
   * If replacement is neither null nor empty but input is not empty, return input.
   * If replacement is either null or empty and type is either null or empty,
   * return input.
   * Otherwise return null.
   *   replacement     input      type        return
   *    AAA             nullptr    *           AAA
   *    AAA             BBB        *           BBB
   *    nullptr || ""   CCC        nullptr     CCC
   *    nullptr || ""   *          DDD         nullptr
   */
  inline const char* deleteOrReplace(
          const char* input, const char* type, const char* replacement) {
      return notEmpty(replacement) ?
          ((input == nullptr) ?  replacement : input) :
          ((type == nullptr) ? input  : nullptr);
  }

  inline bool same(const char* a, const char* b) {
      if (a == nullptr && b == nullptr) {
          return true;
      }
      if ((a == nullptr && b != nullptr) ||
          (a != nullptr && b == nullptr)) {
        return false;
      }
      return uprv_strcmp(a, b):: strcmp(a, b) == 0;
  }

  // Gather fields and generate locale ID into out.
  CharString& outputToString(CharString& out, UErrorCode status);

  // Generate the lookup key.
  CharString& generateKey(const char* language, const char* region,
                          const char* variant, CharString& out,
                          UErrorCode status);

  void parseLanguageReplacement(const char* replacement,
                                const char*& replaceLanguage,
                                const char*& replaceScript,
                                const char*& replaceRegion,
                                const char*& replaceVariant,
                                const char*& replaceExtensions,
                                UVector& toBeFreed,
                                UErrorCode& status);

  // Replace by using languageAlias.
  bool replaceLanguage(bool checkLanguage, bool checkRegion,
                       bool checkVariants, UVector& toBeFreed,
                       UErrorCode& status);

  // Replace by using territoryAlias.
  bool replaceTerritory(UVector& toBeFreed, UErrorCode& status);

  // Replace by using scriptAlias.
  bool replaceScript(UErrorCode& status);

  // Replace by using variantAlias.
  bool replaceVariant(UErrorCode& status);

  // Replace by using subdivisionAlias.
  bool replaceSubdivision(StringPiece subdivision,
                          CharString& output, UErrorCode& status);

  // Replace transformed extensions.
  bool replaceTransformedExtensions(
      CharString& transformedExtensions, CharString& output, UErrorCode& status);
1164};

1166CharString&
1167AliasReplacer::generateKey(
      const char* language, const char* region, const char* variant,
      CharString& out, UErrorCode status)
1170{
  out.append(language, status);
  if (notEmpty(region)) {
      out.append(SEP_CHAR'_', status)
          .append(region, status);
  }
  if (notEmpty(variant)) {
     out.append(SEP_CHAR'_', status)
         .append(variant, status);
  }
  return out;
1181}

1183void
1184AliasReplacer::parseLanguageReplacement(
  const char* replacement,
  const char*& replacedLanguage,
  const char*& replacedScript,
  const char*& replacedRegion,
  const char*& replacedVariant,
  const char*& replacedExtensions,
  UVector& toBeFreed,
  UErrorCode& status)
1193{
  if (U_FAILURE(status)) {
      return;
  }
  replacedScript = replacedRegion = replacedVariant
      = replacedExtensions = nullptr;
  if (uprv_strchr(replacement, '_'):: strchr(replacement, '_') == nullptr) {
      replacedLanguage = replacement;
      // reach the end, just return it.
      return;
  }
  // We have multiple field so we have to allocate and parse
  CharString* str = new CharString(
      replacement, (int32_t)uprv_strlen(replacement):: strlen(replacement), status);
  LocalPointer<CharString> lpStr(str, status);
  toBeFreed.adoptElement(lpStr.orphan(), status);
  if (U_FAILURE(status)) {
      return;
  }
  char* data = str->data();
  replacedLanguage = (const char*) data;
  char* endOfField = uprv_strchr(data, '_'):: strchr(data, '_');
  *endOfField = '\0'; // null terminiate it.
  endOfField++;
  const char* start = endOfField;
  endOfField = (char*) uprv_strchr(start, '_'):: strchr(start, '_');
  size_t len = 0;
  if (endOfField == nullptr) {
      len = uprv_strlen(start):: strlen(start);
  } else {
      len = endOfField - start;
      *endOfField = '\0'; // null terminiate it.
  }
  if (len == 4 && uprv_isASCIILetteruprv_isASCIILetter_71(*start)) {
      // Got a script
      replacedScript = start;
      if (endOfField == nullptr) {
          return;
      }
      start = endOfField++;
      endOfField = (char*)uprv_strchr(start, '_'):: strchr(start, '_');
      if (endOfField == nullptr) {
          len = uprv_strlen(start):: strlen(start);
      } else {
          len = endOfField - start;
          *endOfField = '\0'; // null terminiate it.
      }
  }
  if (len >= 2 && len <= 3) {
      // Got a region
      replacedRegion = start;
      if (endOfField == nullptr) {
          return;
      }
      start = endOfField++;
      endOfField = (char*)uprv_strchr(start, '_'):: strchr(start, '_');
      if (endOfField == nullptr) {
          len = uprv_strlen(start):: strlen(start);
      } else {
          len = endOfField - start;
          *endOfField = '\0'; // null terminiate it.
      }
  }
  if (len >= 4) {
      // Got a variant
      replacedVariant = start;
      if (endOfField == nullptr) {
          return;
      }
      start = endOfField++;
  }
  replacedExtensions = start;
1265}

1267bool
1268AliasReplacer::replaceLanguage(
      bool checkLanguage, bool checkRegion,
      bool checkVariants, UVector& toBeFreed, UErrorCode& status)
1271{
  if (U_FAILURE(status)) {
      return false;
  }
  if (    (checkRegion && region == nullptr) ||
          (checkVariants && variants.size() == 0)) {
      // Nothing to search.
      return false;
  }
  int32_t variant_size = checkVariants ? variants.size() : 1;
  // Since we may have more than one variant, we need to loop through them.
  const char* searchLanguage = checkLanguage ? language : "und";
  const char* searchRegion = checkRegion ? region : nullptr;
  const char* searchVariant = nullptr;
  for (int32_t variant_index = 0;
          variant_index < variant_size;
          variant_index++) {
      if (checkVariants) {
          U_ASSERT(variant_index < variant_size)(void)0;
          searchVariant = (const char*)(variants.elementAt(variant_index));
      }

      if (searchVariant != nullptr && uprv_strlen(searchVariant):: strlen(searchVariant) < 4) {
          // Do not consider  ill-formed variant subtag.
          searchVariant = nullptr;
      }
      CharString typeKey;
      generateKey(searchLanguage, searchRegion, searchVariant, typeKey,
                  status);
      if (U_FAILURE(status)) {
          return false;
      }
      const char *replacement = data->languageMap().get(typeKey.data());
      if (replacement == nullptr) {
          // Found no replacement data.
          continue;
      }

      const char* replacedLanguage = nullptr;
      const char* replacedScript = nullptr;
      const char* replacedRegion = nullptr;
      const char* replacedVariant = nullptr;
      const char* replacedExtensions = nullptr;
      parseLanguageReplacement(replacement,
                               replacedLanguage,
                               replacedScript,
                               replacedRegion,
                               replacedVariant,
                               replacedExtensions,
                               toBeFreed,
                               status);
      replacedLanguage =
          (replacedLanguage != nullptr && uprv_strcmp(replacedLanguage, "und"):: strcmp(replacedLanguage, "und") == 0) ?
          language : replacedLanguage;
      replacedScript = deleteOrReplace(script, nullptr, replacedScript);
      replacedRegion = deleteOrReplace(region, searchRegion, replacedRegion);
      replacedVariant = deleteOrReplace(
          searchVariant, searchVariant, replacedVariant);

      if (    same(language, replacedLanguage) &&
              same(script, replacedScript) &&
              same(region, replacedRegion) &&
              same(searchVariant, replacedVariant) &&
              replacedExtensions == nullptr) {
          // Replacement produce no changes.
          continue;
      }

      language = replacedLanguage;
      region = replacedRegion;
      script = replacedScript;
      if (searchVariant != nullptr) {
          if (notEmpty(replacedVariant)) {
              variants.setElementAt((void*)replacedVariant, variant_index);
          } else {
              variants.removeElementAt(variant_index);
          }
      }
      if (replacedExtensions != nullptr) {
          // DO NOTHING
          // UTS35 does not specify what should we do if we have extensions in the
          // replacement. Currently we know only the following 4 "BCP47 LegacyRules" have
          // extensions in them languageAlias:
          //  i_default => en_x_i_default
          //  i_enochian => und_x_i_enochian
          //  i_mingo => see_x_i_mingo
          //  zh_min => nan_x_zh_min
          // But all of them are already changed by code inside ultag_parse() before
          // hitting this code.
      }

      // Something changed by language alias data.
      return true;
  }
  // Nothing changed by language alias data.
  return false;
1367}

1369bool
1370AliasReplacer::replaceTerritory(UVector& toBeFreed, UErrorCode& status)
1371{
  if (U_FAILURE(status)) {
      return false;
  }
  if (region == nullptr) {
      // No region to search.
      return false;
  }
  const char *replacement = data->territoryMap().get(region);
  if (replacement == nullptr) {
      // Found no replacement data for this region.
      return false;
  }
  const char* replacedRegion = replacement;
  const char* firstSpace = uprv_strchr(replacement, ' '):: strchr(replacement, ' ');
  if (firstSpace != nullptr) {
      // If there are are more than one region in the replacement.
      // We need to check which one match based on the language.
      // Cannot use nullptr for language because that will construct
      // the default locale, in that case, use "und" to get the correct
      // locale.
      Locale l = LocaleBuilder()
          .setLanguage(language == nullptr ? "und" : language)
          .setScript(script)
          .build(status);
      l.addLikelySubtags(status);
      const char* likelyRegion = l.getCountry();
      LocalPointer<CharString> item;
      if (likelyRegion != nullptr && uprv_strlen(likelyRegion):: strlen(likelyRegion) > 0) {
          size_t len = uprv_strlen(likelyRegion):: strlen(likelyRegion);
          const char* foundInReplacement = uprv_strstr(replacement,:: strstr(replacement, likelyRegion)
                                                       likelyRegion):: strstr(replacement, likelyRegion);
          if (foundInReplacement != nullptr) {
              // Assuming the case there are no three letter region code in
              // the replacement of territoryAlias
              U_ASSERT(foundInReplacement == replacement ||(void)0
                       *(foundInReplacement-1) == ' ')(void)0;
              U_ASSERT(foundInReplacement[len] == ' ' ||(void)0
                       foundInReplacement[len] == '\0')(void)0;
              item.adoptInsteadAndCheckErrorCode(
                  new CharString(foundInReplacement, (int32_t)len, status), status);
          }
      }
      if (item.isNull() && U_SUCCESS(status)) {
          item.adoptInsteadAndCheckErrorCode(
              new CharString(replacement,
                             (int32_t)(firstSpace - replacement), status), status);
      }
      if (U_FAILURE(status)) { return false; }
      replacedRegion = item->data();
      toBeFreed.adoptElement(item.orphan(), status);
      if (U_FAILURE(status)) { return false; }
  }
  U_ASSERT(!same(region, replacedRegion))(void)0;
  region = replacedRegion;
  // The region is changed by data in territory alias.
  return true;
1428}

1430bool
1431AliasReplacer::replaceScript(UErrorCode& status)
1432{
  if (U_FAILURE(status)) {
      return false;
  }
  if (script == nullptr) {
      // No script to search.
      return false;
  }
  const char *replacement = data->scriptMap().get(script);
  if (replacement == nullptr) {
      // Found no replacement data for this script.
      return false;
  }
  U_ASSERT(!same(script, replacement))(void)0;
  script = replacement;
  // The script is changed by data in script alias.
  return true;
1449}

1451bool
1452AliasReplacer::replaceVariant(UErrorCode& status)
1453{
  if (U_FAILURE(status)) {
      return false;
  }
  // Since we may have more than one variant, we need to loop through them.
  for (int32_t i = 0; i < variants.size(); i++) {
      const char *variant = (const char*)(variants.elementAt(i));
      const char *replacement = data->variantMap().get(variant);
      if (replacement == nullptr) {
          // Found no replacement data for this variant.
          continue;
      }
      U_ASSERT((uprv_strlen(replacement) >= 5  &&(void)0
                uprv_strlen(replacement) <= 8) ||(void)0
               (uprv_strlen(replacement) == 4 &&(void)0
                replacement[0] >= '0' &&(void)0
                replacement[0] <= '9'))(void)0;
      if (!same(variant, replacement)) {
          variants.setElementAt((void*)replacement, i);
          // Special hack to handle hepburn-heploc => alalc97
          if (uprv_strcmp(variant, "heploc"):: strcmp(variant, "heploc") == 0) {
              for (int32_t j = 0; j < variants.size(); j++) {
                   if (uprv_strcmp((const char*)(variants.elementAt(j)),:: strcmp((const char*)(variants.elementAt(j)), "hepburn")
                                   "hepburn"):: strcmp((const char*)(variants.elementAt(j)), "hepburn") == 0) {
                       variants.removeElementAt(j);
                   }
              }
          }
          return true;
      }
  }
  return false;
1485}

1487bool
1488AliasReplacer::replaceSubdivision(
  StringPiece subdivision, CharString& output, UErrorCode& status)
1490{
  if (U_FAILURE(status)) {
      return false;
  }
  const char *replacement = data->subdivisionMap().get(subdivision.data());
  if (replacement != nullptr) {
      const char* firstSpace = uprv_strchr(replacement, ' '):: strchr(replacement, ' ');
      // Found replacement data for this subdivision.
      size_t len = (firstSpace != nullptr) ?
          (firstSpace - replacement) : uprv_strlen(replacement):: strlen(replacement);
      if (2 <= len && len <= 8) {
          output.append(replacement, (int32_t)len, status);
          if (2 == len) {
              // Add 'zzzz' based on changes to UTS #35 for CLDR-14312.
              output.append("zzzz", 4, status);
          }
      }
      return true;
  }
  return false;
1510}

1512bool
1513AliasReplacer::replaceTransformedExtensions(
  CharString& transformedExtensions, CharString& output, UErrorCode& status)
1515{
  // The content of the transformedExtensions will be modified in this
  // function to NULL-terminating (tkey-tvalue) pairs.
  if (U_FAILURE(status)) {
      return false;
  }
  int32_t len = transformedExtensions.length();
  const char* str = transformedExtensions.data();
  const char* tkey = ultag_getTKeyStartultag_getTKeyStart_71(str);
  int32_t tlangLen = (tkey == str) ? 0 :
      ((tkey == nullptr) ? len : static_cast<int32_t>((tkey - str - 1)));
  CharStringByteSink sink(&output);
  if (tlangLen > 0) {
      Locale tlang = LocaleBuilder()
          .setLanguageTag(StringPiece(str, tlangLen))
          .build(status);
      tlang.canonicalize(status);
      tlang.toLanguageTag(sink, status);
      if (U_FAILURE(status)) {
          return false;
      }
      T_CString_toLowerCaseT_CString_toLowerCase_71(output.data());
  }
  if (tkey != nullptr) {
      // We need to sort the tfields by tkey
      UVector tfields(status);
      if (U_FAILURE(status)) {
          return false;
      }
      do {
          const char* tvalue = uprv_strchr(tkey, '-'):: strchr(tkey, '-');
          if (tvalue == nullptr) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
              return false;
          }
          const char* nextTKey = ultag_getTKeyStartultag_getTKeyStart_71(tvalue);
          if (nextTKey != nullptr) {
              *((char*)(nextTKey-1)) = '\0';  // NULL terminate tvalue
          }
          tfields.insertElementAt((void*)tkey, tfields.size(), status);
          if (U_FAILURE(status)) {
              return false;
          }
          tkey = nextTKey;
      } while (tkey != nullptr);
      tfields.sort([](UElement e1, UElement e2) -> int32_t {
          return uprv_strcmp((const char*)e1.pointer, (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);
      }, status);
      for (int32_t i = 0; i < tfields.size(); i++) {
           if (output.length() > 0) {
               output.append('-', status);
           }
           const char* tfield = (const char*) tfields.elementAt(i);
           const char* tvalue = uprv_strchr(tfield, '-'):: strchr(tfield, '-');
           if (tvalue == nullptr) {
               status = U_ILLEGAL_ARGUMENT_ERROR;
               return false;
           }
           // Split the "tkey-tvalue" pair string so that we can canonicalize the tvalue.
           *((char*)tvalue++) = '\0'; // NULL terminate tkey
           output.append(tfield, status).append('-', status);
           const char* bcpTValue = ulocimp_toBcpTypeulocimp_toBcpType_71(tfield, tvalue, nullptr, nullptr);
           output.append((bcpTValue == nullptr) ? tvalue : bcpTValue, status);
      }
  }
  if (U_FAILURE(status)) {
      return false;
  }
  return true;
1584}

1586CharString&
1587AliasReplacer::outputToString(
  CharString& out, UErrorCode status)
1589{
  out.append(language, status);
  if (notEmpty(script)) {
      out.append(SEP_CHAR'_', status)
          .append(script, status);
  }
  if (notEmpty(region)) {
      out.append(SEP_CHAR'_', status)
          .append(region, status);
  }
  if (variants.size() > 0) {
      if (!notEmpty(script) && !notEmpty(region)) {
        out.append(SEP_CHAR'_', status);
      }
      variants.sort([](UElement e1, UElement e2) -> int32_t {
          return uprv_strcmp((const char*)e1.pointer, (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);
      }, status);
      int32_t variantsStart = out.length();
      for (int32_t i = 0; i < variants.size(); i++) {
           out.append(SEP_CHAR'_', status)
               .append((const char*)(variants.elementAt(i)),
                       status);
      }
      T_CString_toUpperCaseT_CString_toUpperCase_71(out.data() + variantsStart);
  }
  if (notEmpty(extensions)) {
      CharString tmp("und_", status);
      tmp.append(extensions, status);
      Locale tmpLocale(tmp.data());
      // only support x extension inside CLDR for now.
      U_ASSERT(extensions[0] == 'x')(void)0;
      out.append(tmpLocale.getName() + 1, status);
  }
  return out;
1623}

1625bool
1626AliasReplacer::replace(const Locale& locale, CharString& out, UErrorCode& status)
1627{
  data = AliasData::singleton(status);
  if (U_FAILURE(status)) {
      return false;
  }
  U_ASSERT(data != nullptr)(void)0;
  out.clear();
  language = locale.getLanguage();
  if (!notEmpty(language)) {
      language = nullptr;
  }
  script = locale.getScript();
  if (!notEmpty(script)) {
      script = nullptr;
  }
  region = locale.getCountry();
  if (!notEmpty(region)) {
      region = nullptr;
  }
  const char* variantsStr = locale.getVariant();
  CharString variantsBuff(variantsStr, -1, status);
  if (!variantsBuff.isEmpty()) {
      if (U_FAILURE(status)) { return false; }
      char* start = variantsBuff.data();
      T_CString_toLowerCaseT_CString_toLowerCase_71(start);
      char* end;
      while ((end = uprv_strchr(start, SEP_CHAR):: strchr(start, '_')) != nullptr &&
             U_SUCCESS(status)) {
          *end = NULL_CHAR'\0';  // null terminate inside variantsBuff
          variants.addElement(start, status);
          start = end + 1;
      }
      variants.addElement(start, status);
  }
  if (U_FAILURE(status)) { return false; }

  // Sort the variants
  variants.sort([](UElement e1, UElement e2) -> int32_t {
      return uprv_strcmp((const char*)e1.pointer, (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);
  }, status);

  // A changed count to assert when loop too many times.
  int changed = 0;
  // A UVector to to hold CharString allocated by the replace* method
  // and freed when out of scope from his function.
  UVector stringsToBeFreed([](void *obj){ delete ((CharString*) obj); },
                           nullptr, 10, status);
  while (U_SUCCESS(status)) {
      // Something wrong with the data cause looping here more than 10 times
      // already.
      U_ASSERT(changed < 5)(void)0;
      // From observation of key in data/misc/metadata.txt
      // we know currently we only need to search in the following combination
      // of fields for type in languageAlias:
      // * lang_region_variant
      // * lang_region
      // * lang_variant
      // * lang
      // * und_variant
      // This assumption is ensured by the U_ASSERT in readLanguageAlias
      //
      //                      lang  REGION variant
      if (    replaceLanguage(true, true,  true,  stringsToBeFreed, status) ||
              replaceLanguage(true, true,  false, stringsToBeFreed, status) ||
              replaceLanguage(true, false, true,  stringsToBeFreed, status) ||
              replaceLanguage(true, false, false, stringsToBeFreed, status) ||
              replaceLanguage(false,false, true,  stringsToBeFreed, status) ||
              replaceTerritory(stringsToBeFreed, status) ||
              replaceScript(status) ||
              replaceVariant(status)) {
          // Some values in data is changed, try to match from the beginning
          // again.
          changed++;
          continue;
      }
      // Nothing changed. Break out.
      break;
  }  // while(1)

  if (U_FAILURE(status)) { return false; }
  // Nothing changed and we know the order of the variants are not change
  // because we have no variant or only one.
  const char* extensionsStr = locale_getKeywordsStartlocale_getKeywordsStart_71(locale.getName());
  if (changed == 0 && variants.size() <= 1 && extensionsStr == nullptr) {
      return false;
  }
  outputToString(out, status);
  if (U_FAILURE(status)) {
      return false;
  }
  if (extensionsStr != nullptr) {
      changed = 0;
      Locale temp(locale);
      LocalPointer<icu::StringEnumeration> iter(locale.createKeywords(status));
      if (U_SUCCESS(status) && !iter.isNull()) {
          const char* key;
          while ((key = iter->next(nullptr, status)) != nullptr) {
              if (uprv_strcmp("sd", key):: strcmp("sd", key) == 0 || uprv_strcmp("rg", key):: strcmp("rg", key) == 0 ||
                      uprv_strcmp("t", key):: strcmp("t", key) == 0) {
                  CharString value;
                  CharStringByteSink valueSink(&value);
                  locale.getKeywordValue(key, valueSink, status);
                  if (U_FAILURE(status)) {
                      status = U_ZERO_ERROR;
                      continue;
                  }
                  CharString replacement;
                  if (uprv_strlen(key):: strlen(key) == 2) {
                      if (replaceSubdivision(value.toStringPiece(), replacement, status)) {
                          changed++;
                          temp.setKeywordValue(key, replacement.data(), status);
                      }
                  } else {
                      U_ASSERT(uprv_strcmp(key, "t") == 0)(void)0;
                      if (replaceTransformedExtensions(value, replacement, status)) {
                          changed++;
                          temp.setKeywordValue(key, replacement.data(), status);
                      }
                  }
                  if (U_FAILURE(status)) {
                      return false;
                  }
              }
          }
      }
      if (changed != 0) {
          extensionsStr = locale_getKeywordsStartlocale_getKeywordsStart_71(temp.getName());
      }
      out.append(extensionsStr, status);
  }
  if (U_FAILURE(status)) {
      return false;
  }
  // If the tag is not changed, return.
  if (uprv_strcmp(out.data(), locale.getName()):: strcmp(out.data(), locale.getName()) == 0) {
      out.clear();
      return false;
  }
  return true;
1766}

1768// Return true if the locale is changed during canonicalization.
1769// The replaced value then will be put into out.
1770bool
1771canonicalizeLocale(const Locale& locale, CharString& out, UErrorCode& status)
1772{
  AliasReplacer replacer(status);
  return replacer.replace(locale, out, status);
1775}

1777// Function to optimize for known cases without so we can skip the loading
1778// of resources in the startup time until we really need it.
1779bool
1780isKnownCanonicalizedLocale(const char* locale, UErrorCode& status)
1781{
  if (    uprv_strcmp(locale, "c"):: strcmp(locale, "c") == 0 ||
          uprv_strcmp(locale, "en"):: strcmp(locale, "en") == 0 ||
          uprv_strcmp(locale, "en_US"):: strcmp(locale, "en_US") == 0) {
      return true;
  }

  // common well-known Canonicalized.
  umtx_initOnce(gKnownCanonicalizedInitOnce,
                &loadKnownCanonicalized, status);
  if (U_FAILURE(status)) {
      return false;
  }
  U_ASSERT(gKnownCanonicalized != nullptr)(void)0;
  return uhash_getiuhash_geti_71(gKnownCanonicalized, locale) != 0;
1796}

1798}  // namespace

1800// Function for testing.
1801U_CAPIextern "C" const char* const*
1802ulocimp_getKnownCanonicalizedLocaleForTestulocimp_getKnownCanonicalizedLocaleForTest_71(int32_t* length)
1803{
  *length = UPRV_LENGTHOF(KNOWN_CANONICALIZED)(int32_t)(sizeof(KNOWN_CANONICALIZED)/sizeof((KNOWN_CANONICALIZED
)[0]));
  return KNOWN_CANONICALIZED;
1806}

1808// Function for testing.
1809U_CAPIextern "C" bool
1810ulocimp_isCanonicalizedLocaleForTestulocimp_isCanonicalizedLocaleForTest_71(const char* localeName)
1811{
  Locale l(localeName);
  UErrorCode status = U_ZERO_ERROR;
  CharString temp;
  return !canonicalizeLocale(l, temp, status) && U_SUCCESS(status);
1816}

1818/*This function initializes a Locale from a C locale ID*/
1819Locale& Locale::init(const char* localeID, UBool canonicalize)
1820{
  fIsBogus = FALSE0;
  /* Free our current storage */
  if ((baseName != fullName) && (baseName != fullNameBuffer)) {
      uprv_freeuprv_free_71(baseName);
  }
  baseName = NULL__null;
  if(fullName != fullNameBuffer) {
      uprv_freeuprv_free_71(fullName);
      fullName = fullNameBuffer;
  }

  // not a loop:
  // just an easy way to have a common error-exit
  // without goto and without another function
  do {
      char *separator;
      char *field[5] = {0};
      int32_t fieldLen[5] = {0};
      int32_t fieldIdx;
      int32_t variantField;
      int32_t length;
      UErrorCode err;

      if(localeID == NULL__null) {
          // not an error, just set the default locale
          return *this = getDefault();
      }

      /* preset all fields to empty */
      language[0] = script[0] = country[0] = 0;

      // "canonicalize" the locale ID to ICU/Java format
      err = U_ZERO_ERROR;
      length = canonicalize ?
          uloc_canonicalizeuloc_canonicalize_71(localeID, fullName, sizeof(fullNameBuffer), &err) :
          uloc_getNameuloc_getName_71(localeID, fullName, sizeof(fullNameBuffer), &err);

      if(err == U_BUFFER_OVERFLOW_ERROR || length >= (int32_t)sizeof(fullNameBuffer)) {
          U_ASSERT(baseName == nullptr)(void)0;
          /*Go to heap for the fullName if necessary*/
          fullName = (char *)uprv_mallocuprv_malloc_71(sizeof(char)*(length + 1));
          if(fullName == 0) {
              fullName = fullNameBuffer;
              break; // error: out of memory
          }
          err = U_ZERO_ERROR;
          length = canonicalize ?
              uloc_canonicalizeuloc_canonicalize_71(localeID, fullName, length+1, &err) :
              uloc_getNameuloc_getName_71(localeID, fullName, length+1, &err);
      }
      if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) {
          /* should never occur */
          break;
      }

      variantBegin = length;

      /* after uloc_getName/canonicalize() we know that only '_' are separators */
      /* But _ could also appeared in timezone such as "en@timezone=America/Los_Angeles" */
      separator = field[0] = fullName;
      fieldIdx = 1;
      char* at = uprv_strchr(fullName, '@'):: strchr(fullName, '@');
      while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR):: strchr(field[fieldIdx-1], '_')) != 0 &&
             fieldIdx < UPRV_LENGTHOF(field)(int32_t)(sizeof(field)/sizeof((field)[0]))-1 &&
             (at == nullptr || separator < at)) {
          field[fieldIdx] = separator + 1;
          fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]);
          fieldIdx++;
      }
      // variant may contain @foo or .foo POSIX cruft; remove it
      separator = uprv_strchr(field[fieldIdx-1], '@'):: strchr(field[fieldIdx-1], '@');
      char* sep2 = uprv_strchr(field[fieldIdx-1], '.'):: strchr(field[fieldIdx-1], '.');
      if (separator!=NULL__null || sep2!=NULL__null) {
          if (separator==NULL__null || (sep2!=NULL__null && separator > sep2)) {
              separator = sep2;
          }
          fieldLen[fieldIdx-1] = (int32_t)(separator - field[fieldIdx-1]);
      } else {
          fieldLen[fieldIdx-1] = length - (int32_t)(field[fieldIdx-1] - fullName);
      }

      if (fieldLen[0] >= (int32_t)(sizeof(language)))
      {
          break; // error: the language field is too long
      }

      variantField = 1; /* Usually the 2nd one, except when a script or country is also used. */
      if (fieldLen[0] > 0) {
          /* We have a language */
          uprv_memcpy(language, fullName, fieldLen[0])do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(language,
 fullName, fieldLen[0]); } while (false);
          language[fieldLen[0]] = 0;
      }
      if (fieldLen[1] == 4 && uprv_isASCIILetteruprv_isASCIILetter_71(field[1][0]) &&
              uprv_isASCIILetteruprv_isASCIILetter_71(field[1][1]) && uprv_isASCIILetteruprv_isASCIILetter_71(field[1][2]) &&
              uprv_isASCIILetteruprv_isASCIILetter_71(field[1][3])) {
          /* We have at least a script */
          uprv_memcpy(script, field[1], fieldLen[1])do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(script, field
[1], fieldLen[1]); } while (false);
          script[fieldLen[1]] = 0;
          variantField++;
      }

      if (fieldLen[variantField] == 2 || fieldLen[variantField] == 3) {
          /* We have a country */
          uprv_memcpy(country, field[variantField], fieldLen[variantField])do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(country, field
[variantField], fieldLen[variantField]); } while (false);
          country[fieldLen[variantField]] = 0;
          variantField++;
      } else if (fieldLen[variantField] == 0) {
          variantField++; /* script or country empty but variant in next field (i.e. en__POSIX) */
      }

      if (fieldLen[variantField] > 0) {
          /* We have a variant */
          variantBegin = (int32_t)(field[variantField] - fullName);
      }

      err = U_ZERO_ERROR;
      initBaseName(err);
      if (U_FAILURE(err)) {
          break;
      }

      if (canonicalize) {
          if (!isKnownCanonicalizedLocale(fullName, err)) {
              CharString replaced;
              // Not sure it is already canonicalized
              if (canonicalizeLocale(*this, replaced, err)) {
                  U_ASSERT(U_SUCCESS(err))(void)0;
                  // If need replacement, call init again.
                  init(replaced.data(), false);
              }
              if (U_FAILURE(err)) {
                  break;
              }
          }
      }   // if (canonicalize) {

      // successful end of init()
      return *this;
  } while(0); /*loop doesn't iterate*/

  // when an error occurs, then set this object to "bogus" (there is no UErrorCode here)
  setToBogus();

  return *this;
1965}

1967/*
* Set up the base name.
* If there are no key words, it's exactly the full name.
* If key words exist, it's the full name truncated at the '@' character.
* Need to set up both at init() and after setting a keyword.
*/
1973void
1974Locale::initBaseName(UErrorCode &status) {
  if (U_FAILURE(status)) {
      return;
  }
  U_ASSERT(baseName==NULL || baseName==fullName)(void)0;
  const char *atPtr = uprv_strchr(fullName, '@'):: strchr(fullName, '@');
  const char *eqPtr = uprv_strchr(fullName, '='):: strchr(fullName, '=');
  if (atPtr && eqPtr && atPtr < eqPtr) {
      // Key words exist.
      int32_t baseNameLength = (int32_t)(atPtr - fullName);
      baseName = (char *)uprv_mallocuprv_malloc_71(baseNameLength + 1);
      if (baseName == NULL__null) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return;
      }
      uprv_strncpy(baseName, fullName, baseNameLength):: strncpy(baseName, fullName, baseNameLength);
      baseName[baseNameLength] = 0;

      // The original computation of variantBegin leaves it equal to the length
      // of fullName if there is no variant.  It should instead be
      // the length of the baseName.
      if (variantBegin > baseNameLength) {
          variantBegin = baseNameLength;
      }
  } else {
      baseName = fullName;
  }
2001}


2004int32_t
2005Locale::hashCode() const
2006{
  return ustr_hashCharsNustr_hashCharsN_71(fullName, static_cast<int32_t>(uprv_strlen(fullName):: strlen(fullName)));
2008}

2010void
2011Locale::setToBogus() {
  /* Free our current storage */
  if((baseName != fullName) && (baseName != fullNameBuffer)) {
      uprv_freeuprv_free_71(baseName);
  }
  baseName = NULL__null;
  if(fullName != fullNameBuffer) {
      uprv_freeuprv_free_71(fullName);
      fullName = fullNameBuffer;
  }
  *fullNameBuffer = 0;
  *language = 0;
  *script = 0;
  *country = 0;
  fIsBogus = TRUE1;
  variantBegin = 0;
2027}

2029const Locale& U_EXPORT2
2030Locale::getDefault()
2031{
  {
      Mutex lock(&gDefaultLocaleMutex);
      if (gDefaultLocale != NULL__null) {
          return *gDefaultLocale;
      }
  }
  UErrorCode status = U_ZERO_ERROR;
  return *locale_set_default_internal(NULL__null, status);
2040}



2044void U_EXPORT2
2045Locale::setDefault( const   Locale&     newLocale,
                          UErrorCode&  status)
2047{
  if (U_FAILURE(status)) {
      return;
  }

  /* Set the default from the full name string of the supplied locale.
   * This is a convenient way to access the default locale caching mechanisms.
   */
  const char *localeID = newLocale.getName();
  locale_set_default_internal(localeID, status);
2057}

2059void
2060Locale::addLikelySubtags(UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }

  CharString maximizedLocaleID;
  {
      CharStringByteSink sink(&maximizedLocaleID);
      ulocimp_addLikelySubtagsulocimp_addLikelySubtags_71(fullName, sink, &status);
  }

  if (U_FAILURE(status)) {
      return;
  }

  init(maximizedLocaleID.data(), /*canonicalize=*/FALSE0);
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2079}

2081void
2082Locale::minimizeSubtags(UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }

  CharString minimizedLocaleID;
  {
      CharStringByteSink sink(&minimizedLocaleID);
      ulocimp_minimizeSubtagsulocimp_minimizeSubtags_71(fullName, sink, &status);
  }

  if (U_FAILURE(status)) {
      return;
  }

  init(minimizedLocaleID.data(), /*canonicalize=*/FALSE0);
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2101}

2103void
2104Locale::canonicalize(UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  CharString uncanonicalized(fullName, status);
  if (U_FAILURE(status)) {
      return;
  }
  init(uncanonicalized.data(), /*canonicalize=*/TRUE1);
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2120}

2122Locale U_EXPORT2
2123Locale::forLanguageTag(StringPiece tag, UErrorCode& status)
2124{
  Locale result(Locale::eBOGUS);

  if (U_FAILURE(status)) {
      return result;
  }

  // If a BCP 47 language tag is passed as the language parameter to the
  // normal Locale constructor, it will actually fall back to invoking
  // uloc_forLanguageTag() to parse it if it somehow is able to detect that
  // the string actually is BCP 47. This works well for things like strings
  // using BCP 47 extensions, but it does not at all work for things like
  // legacy language tags (marked as “Type: grandfathered” in BCP 47,
  // e.g., "en-GB-oed") which are possible to also
  // interpret as ICU locale IDs and because of that won't trigger the BCP 47
  // parsing. Therefore the code here explicitly calls uloc_forLanguageTag()
  // and then Locale::init(), instead of just calling the normal constructor.

  CharString localeID;
  int32_t parsedLength;
  {
      CharStringByteSink sink(&localeID);
      ulocimp_forLanguageTagulocimp_forLanguageTag_71(
              tag.data(),
              tag.length(),
              sink,
              &parsedLength,
              &status);
  }

  if (U_FAILURE(status)) {
      return result;
  }

  if (parsedLength != tag.size()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return result;
  }

  result.init(localeID.data(), /*canonicalize=*/FALSE0);
  if (result.isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
  return result;
2168}

2170void
2171Locale::toLanguageTag(ByteSink& sink, UErrorCode& status) const
2172{
  if (U_FAILURE(status)) {
      return;
  }

  if (fIsBogus) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  ulocimp_toLanguageTagulocimp_toLanguageTag_71(fullName, sink, /*strict=*/FALSE0, &status);
2183}

2185Locale U_EXPORT2
2186Locale::createFromName (const char *name)
2187{
  if (name) {
      Locale l("");
      l.init(name, FALSE0);
      return l;
  }
  else {
      return getDefault();
  }
2196}

2198Locale U_EXPORT2
2199Locale::createCanonical(const char* name) {
  Locale loc("");
  loc.init(name, TRUE1);
  return loc;
2203}

2205const char *
2206Locale::getISO3Language() const
2207{
  return uloc_getISO3Languageuloc_getISO3Language_71(fullName);
2209}


2212const char *
2213Locale::getISO3Country() const
2214{
  return uloc_getISO3Countryuloc_getISO3Country_71(fullName);
2216}

2218/**
* Return the LCID value as specified in the "LocaleID" resource for this
* locale.  The LocaleID must be expressed as a hexadecimal number, from
* one to four digits.  If the LocaleID resource is not present, or is
* in an incorrect format, 0 is returned.  The LocaleID is for use in
* Windows (it is an LCID), but is available on all platforms.
*/
2225uint32_t
2226Locale::getLCID() const
2227{
  return uloc_getLCIDuloc_getLCID_71(fullName);
2229}

2231const char* const* U_EXPORT2 Locale::getISOCountries()
2232{
  return uloc_getISOCountriesuloc_getISOCountries_71();
2234}

2236const char* const* U_EXPORT2 Locale::getISOLanguages()
2237{
  return uloc_getISOLanguagesuloc_getISOLanguages_71();
2239}

2241// Set the locale's data based on a posix id.
2242void Locale::setFromPOSIXID(const char *posixID)
2243{
  init(posixID, TRUE1);
2245}

2247const Locale & U_EXPORT2
2248Locale::getRoot(void)
2249{
  return getLocale(eROOT);
2251}

2253const Locale & U_EXPORT2
2254Locale::getEnglish(void)
2255{
  return getLocale(eENGLISH);
2257}

2259const Locale & U_EXPORT2
2260Locale::getFrench(void)
2261{
  return getLocale(eFRENCH);
2263}

2265const Locale & U_EXPORT2
2266Locale::getGerman(void)
2267{
  return getLocale(eGERMAN);
2269}

2271const Locale & U_EXPORT2
2272Locale::getItalian(void)
2273{
  return getLocale(eITALIAN);
2275}

2277const Locale & U_EXPORT2
2278Locale::getJapanese(void)
2279{
  return getLocale(eJAPANESE);
2281}

2283const Locale & U_EXPORT2
2284Locale::getKorean(void)
2285{
  return getLocale(eKOREAN);
2287}

2289const Locale & U_EXPORT2
2290Locale::getChinese(void)
2291{
  return getLocale(eCHINESE);
2293}

2295const Locale & U_EXPORT2
2296Locale::getSimplifiedChinese(void)
2297{
  return getLocale(eCHINA);
2299}

2301const Locale & U_EXPORT2
2302Locale::getTraditionalChinese(void)
2303{
  return getLocale(eTAIWAN);
2305}


2308const Locale & U_EXPORT2
2309Locale::getFrance(void)
2310{
  return getLocale(eFRANCE);
2312}

2314const Locale & U_EXPORT2
2315Locale::getGermany(void)
2316{
  return getLocale(eGERMANY);
2318}

2320const Locale & U_EXPORT2
2321Locale::getItaly(void)
2322{
  return getLocale(eITALY);
2324}

2326const Locale & U_EXPORT2
2327Locale::getJapan(void)
2328{
  return getLocale(eJAPAN);
2330}

2332const Locale & U_EXPORT2
2333Locale::getKorea(void)
2334{
  return getLocale(eKOREA);
2336}

2338const Locale & U_EXPORT2
2339Locale::getChina(void)
2340{
  return getLocale(eCHINA);
2342}

2344const Locale & U_EXPORT2
2345Locale::getPRC(void)
2346{
  return getLocale(eCHINA);
2348}

2350const Locale & U_EXPORT2
2351Locale::getTaiwan(void)
2352{
  return getLocale(eTAIWAN);
2354}

2356const Locale & U_EXPORT2
2357Locale::getUK(void)
2358{
  return getLocale(eUK);
2360}

2362const Locale & U_EXPORT2
2363Locale::getUS(void)
2364{
  return getLocale(eUS);
2366}

2368const Locale & U_EXPORT2
2369Locale::getCanada(void)
2370{
  return getLocale(eCANADA);
2372}

2374const Locale & U_EXPORT2
2375Locale::getCanadaFrench(void)
2376{
  return getLocale(eCANADA_FRENCH);
1
Calling 'Locale::getLocale'→
2378}

2380const Locale &
2381Locale::getLocale(int locid)
2382{
  Locale *localeCache = getLocaleCache();
2
←
'localeCache' initialized here→
  U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0))(void)0;
  if (localeCache == NULL__null) {
3
←
Assuming 'localeCache' is equal to NULL→
4
←
Taking true branch→
      // Failure allocating the locale cache.
      //   The best we can do is return a NULL reference.
      locid = 0;
  }
  return localeCache[locid]; /*operating on NULL*/
5
←
Returning null reference
2391}

2393/*
2394This function is defined this way in order to get around static
2395initialization and static destruction.
*/
2397Locale *
2398Locale::getLocaleCache(void)
2399{
  UErrorCode status = U_ZERO_ERROR;
  umtx_initOnce(gLocaleCacheInitOnce, locale_init, status);
  return gLocaleCache;
2403}

2405class KeywordEnumeration : public StringEnumeration {
2406private:
  char *keywords;
  char *current;
  int32_t length;
  UnicodeString currUSKey;
  static const char fgClassID;/* Warning this is used beyond the typical RTTI usage. */

2413public:
  static UClassID U_EXPORT2 getStaticClassID(void) { return (UClassID)&fgClassID; }
  virtual UClassID getDynamicClassID(void) const override { return getStaticClassID(); }
2416public:
  KeywordEnumeration(const char *keys, int32_t keywordLen, int32_t currentIndex, UErrorCode &status)
      : keywords((char *)&fgClassID), current((char *)&fgClassID), length(0) {
      if(U_SUCCESS(status) && keywordLen != 0) {
          if(keys == NULL__null || keywordLen < 0) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
          } else {
              keywords = (char *)uprv_mallocuprv_malloc_71(keywordLen+1);
              if (keywords == NULL__null) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              }
              else {
                  uprv_memcpy(keywords, keys, keywordLen)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(keywords,
 keys, keywordLen); } while (false);
                  keywords[keywordLen] = 0;
                  current = keywords + currentIndex;
                  length = keywordLen;
              }
          }
      }
  }

  virtual ~KeywordEnumeration();

  virtual StringEnumeration * clone() const override
  {
      UErrorCode status = U_ZERO_ERROR;
      return new KeywordEnumeration(keywords, length, (int32_t)(current - keywords), status);
  }

  virtual int32_t count(UErrorCode &/*status*/) const override {
      char *kw = keywords;
      int32_t result = 0;
      while(*kw) {
          result++;
          kw += uprv_strlen(kw):: strlen(kw)+1;
      }
      return result;
  }

  virtual const char* next(int32_t* resultLength, UErrorCode& status) override {
      const char* result;
      int32_t len;
      if(U_SUCCESS(status) && *current != 0) {
          result = current;
          len = (int32_t)uprv_strlen(current):: strlen(current);
          current += len+1;
          if(resultLength != NULL__null) {
              *resultLength = len;
          }
      } else {
          if(resultLength != NULL__null) {
              *resultLength = 0;
          }
          result = NULL__null;
      }
      return result;
  }

  virtual const UnicodeString* snext(UErrorCode& status) override {
      int32_t resultLength = 0;
      const char *s = next(&resultLength, status);
      return setChars(s, resultLength, status);
  }

  virtual void reset(UErrorCode& /*status*/) override {
      current = keywords;
  }
2483};

2485const char KeywordEnumeration::fgClassID = '\0';

2487KeywordEnumeration::~KeywordEnumeration() {
  uprv_freeuprv_free_71(keywords);
2489}

2491// A wrapper around KeywordEnumeration that calls uloc_toUnicodeLocaleKey() in
2492// the next() method for each keyword before returning it.
2493class UnicodeKeywordEnumeration : public KeywordEnumeration {
2494public:
  using KeywordEnumeration::KeywordEnumeration;
  virtual ~UnicodeKeywordEnumeration();

  virtual const char* next(int32_t* resultLength, UErrorCode& status) override {
      const char* legacy_key = KeywordEnumeration::next(nullptr, status);
      while (U_SUCCESS(status) && legacy_key != nullptr) {
          const char* key = uloc_toUnicodeLocaleKeyuloc_toUnicodeLocaleKey_71(legacy_key);
          if (key != nullptr) {
              if (resultLength != nullptr) {
                  *resultLength = static_cast<int32_t>(uprv_strlen(key):: strlen(key));
              }
              return key;
          }
          // Not a Unicode keyword, could be a t, x or other, continue to look at the next one.
          legacy_key = KeywordEnumeration::next(nullptr, status);
      }
      if (resultLength != nullptr) *resultLength = 0;
      return nullptr;
  }
2514};

2516// Out-of-line virtual destructor to serve as the "key function".
2517UnicodeKeywordEnumeration::~UnicodeKeywordEnumeration() = default;

2519StringEnumeration *
2520Locale::createKeywords(UErrorCode &status) const
2521{
  StringEnumeration *result = NULL__null;

  if (U_FAILURE(status)) {
      return result;
  }

  const char* variantStart = uprv_strchr(fullName, '@'):: strchr(fullName, '@');
  const char* assignment = uprv_strchr(fullName, '='):: strchr(fullName, '=');
  if(variantStart) {
      if(assignment > variantStart) {
          CharString keywords;
          CharStringByteSink sink(&keywords);
          ulocimp_getKeywordsulocimp_getKeywords_71(variantStart+1, '@', sink, FALSE0, &status);
          if (U_SUCCESS(status) && !keywords.isEmpty()) {
              result = new KeywordEnumeration(keywords.data(), keywords.length(), 0, status);
              if (!result) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              }
          }
      } else {
          status = U_INVALID_FORMAT_ERROR;
      }
  }
  return result;
2546}

2548StringEnumeration *
2549Locale::createUnicodeKeywords(UErrorCode &status) const
2550{
  StringEnumeration *result = NULL__null;

  if (U_FAILURE(status)) {
      return result;
  }

  const char* variantStart = uprv_strchr(fullName, '@'):: strchr(fullName, '@');
  const char* assignment = uprv_strchr(fullName, '='):: strchr(fullName, '=');
  if(variantStart) {
      if(assignment > variantStart) {
          CharString keywords;
          CharStringByteSink sink(&keywords);
          ulocimp_getKeywordsulocimp_getKeywords_71(variantStart+1, '@', sink, FALSE0, &status);
          if (U_SUCCESS(status) && !keywords.isEmpty()) {
              result = new UnicodeKeywordEnumeration(keywords.data(), keywords.length(), 0, status);
              if (!result) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              }
          }
      } else {
          status = U_INVALID_FORMAT_ERROR;
      }
  }
  return result;
2575}

2577int32_t
2578Locale::getKeywordValue(const char* keywordName, char *buffer, int32_t bufLen, UErrorCode &status) const
2579{
  return uloc_getKeywordValueuloc_getKeywordValue_71(fullName, keywordName, buffer, bufLen, &status);
2581}

2583void
2584Locale::getKeywordValue(StringPiece keywordName, ByteSink& sink, UErrorCode& status) const {
  if (U_FAILURE(status)) {
      return;
  }

  if (fIsBogus) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  // TODO: Remove the need for a const char* to a NUL terminated buffer.
  const CharString keywordName_nul(keywordName, status);
  if (U_FAILURE(status)) {
      return;
  }

  ulocimp_getKeywordValueulocimp_getKeywordValue_71(fullName, keywordName_nul.data(), sink, &status);
2601}

2603void
2604Locale::getUnicodeKeywordValue(StringPiece keywordName,
                             ByteSink& sink,
                             UErrorCode& status) const {
  // TODO: Remove the need for a const char* to a NUL terminated buffer.
  const CharString keywordName_nul(keywordName, status);
  if (U_FAILURE(status)) {
      return;
  }

  const char* legacy_key = uloc_toLegacyKeyuloc_toLegacyKey_71(keywordName_nul.data());

  if (legacy_key == nullptr) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  CharString legacy_value;
  {
      CharStringByteSink sink(&legacy_value);
      getKeywordValue(legacy_key, sink, status);
  }

  if (U_FAILURE(status)) {
      return;
  }

  const char* unicode_value = uloc_toUnicodeLocaleTypeuloc_toUnicodeLocaleType_71(
          keywordName_nul.data(), legacy_value.data());

  if (unicode_value == nullptr) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  sink.Append(unicode_value, static_cast<int32_t>(uprv_strlen(unicode_value):: strlen(unicode_value)));
2639}

2641void
2642Locale::setKeywordValue(const char* keywordName, const char* keywordValue, UErrorCode &status)
2643{
  if (U_FAILURE(status)) {
      return;
  }
  if (status == U_STRING_NOT_TERMINATED_WARNING) {
      status = U_ZERO_ERROR;
  }
  int32_t bufferLength = uprv_maxuprv_max_71((int32_t)(uprv_strlen(fullName):: strlen(fullName) + 1), ULOC_FULLNAME_CAPACITY157);
  int32_t newLength = uloc_setKeywordValueuloc_setKeywordValue_71(keywordName, keywordValue, fullName,
                                           bufferLength, &status) + 1;
  U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING)(void)0;
  /* Handle the case the current buffer is not enough to hold the new id */
  if (status == U_BUFFER_OVERFLOW_ERROR) {
      U_ASSERT(newLength > bufferLength)(void)0;
      char* newFullName = (char *)uprv_mallocuprv_malloc_71(newLength);
      if (newFullName == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return;
      }
      uprv_strcpy(newFullName, fullName):: strcpy(newFullName, fullName);
      if (fullName != fullNameBuffer) {
          // if full Name is already on the heap, need to free it.
          uprv_freeuprv_free_71(fullName);
          if (baseName == fullName) {
              baseName = newFullName; // baseName should not point to freed memory.
          }
      }
      fullName = newFullName;
      status = U_ZERO_ERROR;
      uloc_setKeywordValueuloc_setKeywordValue_71(keywordName, keywordValue, fullName, newLength, &status);
      U_ASSERT(status != U_STRING_NOT_TERMINATED_WARNING)(void)0;
  } else {
      U_ASSERT(newLength <= bufferLength)(void)0;
  }
  if (U_SUCCESS(status) && baseName == fullName) {
      // May have added the first keyword, meaning that the fullName is no longer also the baseName.
      initBaseName(status);
  }
2681}

2683void
2684Locale::setKeywordValue(StringPiece keywordName,
                      StringPiece keywordValue,
                      UErrorCode& status) {
  // TODO: Remove the need for a const char* to a NUL terminated buffer.
  const CharString keywordName_nul(keywordName, status);
  const CharString keywordValue_nul(keywordValue, status);
  setKeywordValue(keywordName_nul.data(), keywordValue_nul.data(), status);
2691}

2693void
2694Locale::setUnicodeKeywordValue(StringPiece keywordName,
                             StringPiece keywordValue,
                             UErrorCode& status) {
  // TODO: Remove the need for a const char* to a NUL terminated buffer.
  const CharString keywordName_nul(keywordName, status);
  const CharString keywordValue_nul(keywordValue, status);

  if (U_FAILURE(status)) {
      return;
  }

  const char* legacy_key = uloc_toLegacyKeyuloc_toLegacyKey_71(keywordName_nul.data());

  if (legacy_key == nullptr) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  const char* legacy_value = nullptr;

  if (!keywordValue_nul.isEmpty()) {
      legacy_value =
          uloc_toLegacyTypeuloc_toLegacyType_71(keywordName_nul.data(), keywordValue_nul.data());

      if (legacy_value == nullptr) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
  }

  setKeywordValue(legacy_key, legacy_value, status);
2725}

2727const char *
2728Locale::getBaseName() const {
  return baseName;
2730}

2732Locale::Iterator::~Iterator() = default;

2734//eof
2735U_NAMESPACE_END}