Add m-esr52 at 52.6.0

1 files changed, 1056 insertions, 0 deletions

diff --git a/intl/icu/source/common/locdspnm.cpp b/intl/icu/source/common/locdspnm.cpp
new file mode 100644
index 000000000..a17478ce6
--- /dev/null
+++ b/intl/icu/source/common/locdspnm.cpp
@@ -0,0 +1,1056 @@
+// Copyright (C) 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+*******************************************************************************
+* Copyright (C) 2010-2016, International Business Machines Corporation and
+* others. All Rights Reserved.
+*******************************************************************************
+*/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/locdspnm.h"
+#include "unicode/simpleformatter.h"
+#include "unicode/ures.h"
+#include "unicode/udisplaycontext.h"
+#include "unicode/brkiter.h"
+#include "unicode/ucurr.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "mutex.h"
+#include "ulocimp.h"
+#include "umutex.h"
+#include "ureslocs.h"
+#include "uresimp.h"
+
+#include <stdarg.h>
+
+/**
+ * Concatenate a number of null-terminated strings to buffer, leaving a
+ * null-terminated string.  The last argument should be the null pointer.
+ * Return the length of the string in the buffer, not counting the trailing
+ * null.  Return -1 if there is an error (buffer is null, or buflen < 1).
+ */
+static int32_t ncat(char *buffer, uint32_t buflen, ...) {
+  va_list args;
+  char *str;
+  char *p = buffer;
+  const char* e = buffer + buflen - 1;
+
+  if (buffer == NULL || buflen < 1) {
+    return -1;
+  }
+
+  va_start(args, buflen);
+  while ((str = va_arg(args, char *))) {
+    char c;
+    while (p != e && (c = *str++)) {
+      *p++ = c;
+    }
+  }
+  *p = 0;
+  va_end(args);
+
+  return p - buffer;
+}
+
+U_NAMESPACE_BEGIN
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Access resource data for locale components.
+// Wrap code in uloc.c for now.
+class ICUDataTable {
+    const char* path;
+    Locale locale;
+
+public:
+    ICUDataTable(const char* path, const Locale& locale);
+    ~ICUDataTable();
+
+    const Locale& getLocale();
+
+    UnicodeString& get(const char* tableKey, const char* itemKey,
+                        UnicodeString& result) const;
+    UnicodeString& get(const char* tableKey, const char* subTableKey, const char* itemKey,
+                        UnicodeString& result) const;
+
+    UnicodeString& getNoFallback(const char* tableKey, const char* itemKey,
+                                UnicodeString &result) const;
+    UnicodeString& getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
+                                UnicodeString &result) const;
+};
+
+inline UnicodeString &
+ICUDataTable::get(const char* tableKey, const char* itemKey, UnicodeString& result) const {
+    return get(tableKey, NULL, itemKey, result);
+}
+
+inline UnicodeString &
+ICUDataTable::getNoFallback(const char* tableKey, const char* itemKey, UnicodeString& result) const {
+    return getNoFallback(tableKey, NULL, itemKey, result);
+}
+
+ICUDataTable::ICUDataTable(const char* path, const Locale& locale)
+    : path(NULL), locale(Locale::getRoot())
+{
+  if (path) {
+    int32_t len = uprv_strlen(path);
+    this->path = (const char*) uprv_malloc(len + 1);
+    if (this->path) {
+      uprv_strcpy((char *)this->path, path);
+      this->locale = locale;
+    }
+  }
+}
+
+ICUDataTable::~ICUDataTable() {
+  if (path) {
+    uprv_free((void*) path);
+    path = NULL;
+  }
+}
+
+const Locale&
+ICUDataTable::getLocale() {
+  return locale;
+}
+
+UnicodeString &
+ICUDataTable::get(const char* tableKey, const char* subTableKey, const char* itemKey,
+                  UnicodeString &result) const {
+  UErrorCode status = U_ZERO_ERROR;
+  int32_t len = 0;
+
+  const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
+                                                   tableKey, subTableKey, itemKey,
+                                                   &len, &status);
+  if (U_SUCCESS(status) && len > 0) {
+    return result.setTo(s, len);
+  }
+  return result.setTo(UnicodeString(itemKey, -1, US_INV));
+}
+
+UnicodeString &
+ICUDataTable::getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
+                            UnicodeString& result) const {
+  UErrorCode status = U_ZERO_ERROR;
+  int32_t len = 0;
+
+  const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
+                                                   tableKey, subTableKey, itemKey,
+                                                   &len, &status);
+  if (U_SUCCESS(status)) {
+    return result.setTo(s, len);
+  }
+
+  result.setToBogus();
+  return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+LocaleDisplayNames::~LocaleDisplayNames() {}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if 0  // currently unused
+
+class DefaultLocaleDisplayNames : public LocaleDisplayNames {
+  UDialectHandling dialectHandling;
+
+public:
+  // constructor
+  DefaultLocaleDisplayNames(UDialectHandling dialectHandling);
+
+  virtual ~DefaultLocaleDisplayNames();
+
+  virtual const Locale& getLocale() const;
+  virtual UDialectHandling getDialectHandling() const;
+
+  virtual UnicodeString& localeDisplayName(const Locale& locale,
+                                           UnicodeString& result) const;
+  virtual UnicodeString& localeDisplayName(const char* localeId,
+                                           UnicodeString& result) const;
+  virtual UnicodeString& languageDisplayName(const char* lang,
+                                             UnicodeString& result) const;
+  virtual UnicodeString& scriptDisplayName(const char* script,
+                                           UnicodeString& result) const;
+  virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
+                                           UnicodeString& result) const;
+  virtual UnicodeString& regionDisplayName(const char* region,
+                                           UnicodeString& result) const;
+  virtual UnicodeString& variantDisplayName(const char* variant,
+                                            UnicodeString& result) const;
+  virtual UnicodeString& keyDisplayName(const char* key,
+                                        UnicodeString& result) const;
+  virtual UnicodeString& keyValueDisplayName(const char* key,
+                                             const char* value,
+                                             UnicodeString& result) const;
+};
+
+DefaultLocaleDisplayNames::DefaultLocaleDisplayNames(UDialectHandling dialectHandling)
+    : dialectHandling(dialectHandling) {
+}
+
+DefaultLocaleDisplayNames::~DefaultLocaleDisplayNames() {
+}
+
+const Locale&
+DefaultLocaleDisplayNames::getLocale() const {
+  return Locale::getRoot();
+}
+
+UDialectHandling
+DefaultLocaleDisplayNames::getDialectHandling() const {
+  return dialectHandling;
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::localeDisplayName(const Locale& locale,
+                                             UnicodeString& result) const {
+  return result = UnicodeString(locale.getName(), -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::localeDisplayName(const char* localeId,
+                                             UnicodeString& result) const {
+  return result = UnicodeString(localeId, -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::languageDisplayName(const char* lang,
+                                               UnicodeString& result) const {
+  return result = UnicodeString(lang, -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::scriptDisplayName(const char* script,
+                                             UnicodeString& result) const {
+  return result = UnicodeString(script, -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::scriptDisplayName(UScriptCode scriptCode,
+                                             UnicodeString& result) const {
+  const char* name = uscript_getName(scriptCode);
+  if (name) {
+    return result = UnicodeString(name, -1, US_INV);
+  }
+  return result.remove();
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::regionDisplayName(const char* region,
+                                             UnicodeString& result) const {
+  return result = UnicodeString(region, -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::variantDisplayName(const char* variant,
+                                              UnicodeString& result) const {
+  return result = UnicodeString(variant, -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::keyDisplayName(const char* key,
+                                          UnicodeString& result) const {
+  return result = UnicodeString(key, -1, US_INV);
+}
+
+UnicodeString&
+DefaultLocaleDisplayNames::keyValueDisplayName(const char* /* key */,
+                                               const char* value,
+                                               UnicodeString& result) const {
+  return result = UnicodeString(value, -1, US_INV);
+}
+
+#endif  // currently unused class DefaultLocaleDisplayNames
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+class LocaleDisplayNamesImpl : public LocaleDisplayNames {
+    Locale locale;
+    UDialectHandling dialectHandling;
+    ICUDataTable langData;
+    ICUDataTable regionData;
+    SimpleFormatter separatorFormat;
+    SimpleFormatter format;
+    SimpleFormatter keyTypeFormat;
+    UDisplayContext capitalizationContext;
+#if !UCONFIG_NO_BREAK_ITERATION
+    BreakIterator* capitalizationBrkIter;
+#else
+    UObject* capitalizationBrkIter;
+#endif
+    static UMutex  capitalizationBrkIterLock;
+    UnicodeString formatOpenParen;
+    UnicodeString formatReplaceOpenParen;
+    UnicodeString formatCloseParen;
+    UnicodeString formatReplaceCloseParen;
+    UDisplayContext nameLength;
+
+    // Constants for capitalization context usage types.
+    enum CapContextUsage {
+        kCapContextUsageLanguage,
+        kCapContextUsageScript,
+        kCapContextUsageTerritory,
+        kCapContextUsageVariant,
+        kCapContextUsageKey,
+        kCapContextUsageKeyValue,
+        kCapContextUsageCount
+    };
+    // Capitalization transforms. For each usage type, indicates whether to titlecase for
+    // the context specified in capitalizationContext (which we know at construction time)
+     UBool fCapitalization[kCapContextUsageCount];
+
+public:
+    // constructor
+    LocaleDisplayNamesImpl(const Locale& locale, UDialectHandling dialectHandling);
+    LocaleDisplayNamesImpl(const Locale& locale, UDisplayContext *contexts, int32_t length);
+    virtual ~LocaleDisplayNamesImpl();
+
+    virtual const Locale& getLocale() const;
+    virtual UDialectHandling getDialectHandling() const;
+    virtual UDisplayContext getContext(UDisplayContextType type) const;
+
+    virtual UnicodeString& localeDisplayName(const Locale& locale,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& localeDisplayName(const char* localeId,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& languageDisplayName(const char* lang,
+                                               UnicodeString& result) const;
+    virtual UnicodeString& scriptDisplayName(const char* script,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& regionDisplayName(const char* region,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& variantDisplayName(const char* variant,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& keyDisplayName(const char* key,
+                                                UnicodeString& result) const;
+    virtual UnicodeString& keyValueDisplayName(const char* key,
+                                                const char* value,
+                                                UnicodeString& result) const;
+private:
+    UnicodeString& localeIdName(const char* localeId,
+                                UnicodeString& result) const;
+    UnicodeString& appendWithSep(UnicodeString& buffer, const UnicodeString& src) const;
+    UnicodeString& adjustForUsageAndContext(CapContextUsage usage, UnicodeString& result) const;
+    UnicodeString& scriptDisplayName(const char* script, UnicodeString& result, UBool skipAdjust) const;
+    UnicodeString& regionDisplayName(const char* region, UnicodeString& result, UBool skipAdjust) const;
+    UnicodeString& variantDisplayName(const char* variant, UnicodeString& result, UBool skipAdjust) const;
+    UnicodeString& keyDisplayName(const char* key, UnicodeString& result, UBool skipAdjust) const;
+    UnicodeString& keyValueDisplayName(const char* key, const char* value,
+                                        UnicodeString& result, UBool skipAdjust) const;
+    void initialize(void);
+
+    struct CapitalizationContextSink;
+};
+
+UMutex LocaleDisplayNamesImpl::capitalizationBrkIterLock = U_MUTEX_INITIALIZER;
+
+LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
+                                               UDialectHandling dialectHandling)
+    : dialectHandling(dialectHandling)
+    , langData(U_ICUDATA_LANG, locale)
+    , regionData(U_ICUDATA_REGION, locale)
+    , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
+    , capitalizationBrkIter(NULL)
+    , nameLength(UDISPCTX_LENGTH_FULL)
+{
+    initialize();
+}
+
+LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
+                                               UDisplayContext *contexts, int32_t length)
+    : dialectHandling(ULDN_STANDARD_NAMES)
+    , langData(U_ICUDATA_LANG, locale)
+    , regionData(U_ICUDATA_REGION, locale)
+    , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
+    , capitalizationBrkIter(NULL)
+    , nameLength(UDISPCTX_LENGTH_FULL)
+{
+    while (length-- > 0) {
+        UDisplayContext value = *contexts++;
+        UDisplayContextType selector = (UDisplayContextType)((uint32_t)value >> 8);
+        switch (selector) {
+            case UDISPCTX_TYPE_DIALECT_HANDLING:
+                dialectHandling = (UDialectHandling)value;
+                break;
+            case UDISPCTX_TYPE_CAPITALIZATION:
+                capitalizationContext = value;
+                break;
+            case UDISPCTX_TYPE_DISPLAY_LENGTH:
+                nameLength = value;
+                break;
+            default:
+                break;
+        }
+    }
+    initialize();
+}
+
+struct LocaleDisplayNamesImpl::CapitalizationContextSink : public ResourceSink {
+    UBool hasCapitalizationUsage;
+    LocaleDisplayNamesImpl& parent;
+
+    CapitalizationContextSink(LocaleDisplayNamesImpl& _parent)
+      : hasCapitalizationUsage(FALSE), parent(_parent) {}
+    virtual ~CapitalizationContextSink();
+
+    virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
+            UErrorCode &errorCode) {
+        ResourceTable contexts = value.getTable(errorCode);
+        if (U_FAILURE(errorCode)) { return; }
+        for (int i = 0; contexts.getKeyAndValue(i, key, value); ++i) {
+
+            CapContextUsage usageEnum;
+            if (uprv_strcmp(key, "key") == 0) {
+                usageEnum = kCapContextUsageKey;
+            } else if (uprv_strcmp(key, "keyValue") == 0) {
+                usageEnum = kCapContextUsageKeyValue;
+            } else if (uprv_strcmp(key, "languages") == 0) {
+                usageEnum = kCapContextUsageLanguage;
+            } else if (uprv_strcmp(key, "script") == 0) {
+                usageEnum = kCapContextUsageScript;
+            } else if (uprv_strcmp(key, "territory") == 0) {
+                usageEnum = kCapContextUsageTerritory;
+            } else if (uprv_strcmp(key, "variant") == 0) {
+                usageEnum = kCapContextUsageVariant;
+            } else {
+                continue;
+            }
+
+            int32_t len = 0;
+            const int32_t* intVector = value.getIntVector(len, errorCode);
+            if (U_FAILURE(errorCode)) { return; }
+            if (len < 2) { continue; }
+
+            int32_t titlecaseInt = (parent.capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU) ? intVector[0] : intVector[1];
+            if (titlecaseInt == 0) { continue; }
+
+            parent.fCapitalization[usageEnum] = TRUE;
+            hasCapitalizationUsage = TRUE;
+        }
+    }
+};
+
+// Virtual destructors must be defined out of line.
+LocaleDisplayNamesImpl::CapitalizationContextSink::~CapitalizationContextSink() {}
+
+void
+LocaleDisplayNamesImpl::initialize(void) {
+    LocaleDisplayNamesImpl *nonConstThis = (LocaleDisplayNamesImpl *)this;
+    nonConstThis->locale = langData.getLocale() == Locale::getRoot()
+        ? regionData.getLocale()
+        : langData.getLocale();
+
+    UnicodeString sep;
+    langData.getNoFallback("localeDisplayPattern", "separator", sep);
+    if (sep.isBogus()) {
+        sep = UnicodeString("{0}, {1}", -1, US_INV);
+    }
+    UErrorCode status = U_ZERO_ERROR;
+    separatorFormat.applyPatternMinMaxArguments(sep, 2, 2, status);
+
+    UnicodeString pattern;
+    langData.getNoFallback("localeDisplayPattern", "pattern", pattern);
+    if (pattern.isBogus()) {
+        pattern = UnicodeString("{0} ({1})", -1, US_INV);
+    }
+    format.applyPatternMinMaxArguments(pattern, 2, 2, status);
+    if (pattern.indexOf((UChar)0xFF08) >= 0) {
+        formatOpenParen.setTo((UChar)0xFF08);         // fullwidth (
+        formatReplaceOpenParen.setTo((UChar)0xFF3B);  // fullwidth [
+        formatCloseParen.setTo((UChar)0xFF09);        // fullwidth )
+        formatReplaceCloseParen.setTo((UChar)0xFF3D); // fullwidth ]
+    } else {
+        formatOpenParen.setTo((UChar)0x0028);         // (
+        formatReplaceOpenParen.setTo((UChar)0x005B);  // [
+        formatCloseParen.setTo((UChar)0x0029);        // )
+        formatReplaceCloseParen.setTo((UChar)0x005D); // ]
+    }
+
+    UnicodeString ktPattern;
+    langData.get("localeDisplayPattern", "keyTypePattern", ktPattern);
+    if (ktPattern.isBogus()) {
+        ktPattern = UnicodeString("{0}={1}", -1, US_INV);
+    }
+    keyTypeFormat.applyPatternMinMaxArguments(ktPattern, 2, 2, status);
+
+    uprv_memset(fCapitalization, 0, sizeof(fCapitalization));
+#if !UCONFIG_NO_BREAK_ITERATION
+    // Only get the context data if we need it! This is a const object so we know now...
+    // Also check whether we will need a break iterator (depends on the data)
+    UBool needBrkIter = FALSE;
+    if (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU || capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_STANDALONE) {
+        LocalUResourceBundlePointer resource(ures_open(NULL, locale.getName(), &status));
+        if (U_FAILURE(status)) { return; }
+        CapitalizationContextSink sink(*this);
+        ures_getAllItemsWithFallback(resource.getAlias(), "contextTransforms", sink, status);
+        if (status == U_MISSING_RESOURCE_ERROR) {
+            // Silently ignore.  Not every locale has contextTransforms.
+            status = U_ZERO_ERROR;
+        } else if (U_FAILURE(status)) {
+            return;
+        }
+        needBrkIter = sink.hasCapitalizationUsage;
+    }
+    // Get a sentence break iterator if we will need it
+    if (needBrkIter || capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE) {
+        status = U_ZERO_ERROR;
+        capitalizationBrkIter = BreakIterator::createSentenceInstance(locale, status);
+        if (U_FAILURE(status)) {
+            delete capitalizationBrkIter;
+            capitalizationBrkIter = NULL;
+        }
+    }
+#endif
+}
+
+LocaleDisplayNamesImpl::~LocaleDisplayNamesImpl() {
+#if !UCONFIG_NO_BREAK_ITERATION
+    delete capitalizationBrkIter;
+#endif
+}
+
+const Locale&
+LocaleDisplayNamesImpl::getLocale() const {
+    return locale;
+}
+
+UDialectHandling
+LocaleDisplayNamesImpl::getDialectHandling() const {
+    return dialectHandling;
+}
+
+UDisplayContext
+LocaleDisplayNamesImpl::getContext(UDisplayContextType type) const {
+    switch (type) {
+        case UDISPCTX_TYPE_DIALECT_HANDLING:
+            return (UDisplayContext)dialectHandling;
+        case UDISPCTX_TYPE_CAPITALIZATION:
+            return capitalizationContext;
+        case UDISPCTX_TYPE_DISPLAY_LENGTH:
+            return nameLength;
+        default:
+            break;
+    }
+    return (UDisplayContext)0;
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::adjustForUsageAndContext(CapContextUsage usage,
+                                                UnicodeString& result) const {
+#if !UCONFIG_NO_BREAK_ITERATION
+    // check to see whether we need to titlecase result
+    if ( result.length() > 0 && u_islower(result.char32At(0)) && capitalizationBrkIter!= NULL &&
+          ( capitalizationContext==UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE || fCapitalization[usage] ) ) {
+        // note fCapitalization[usage] won't be set unless capitalizationContext is UI_LIST_OR_MENU or STANDALONE
+        Mutex lock(&capitalizationBrkIterLock);
+        result.toTitle(capitalizationBrkIter, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
+    }
+#endif
+    return result;
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::localeDisplayName(const Locale& locale,
+                                          UnicodeString& result) const {
+  if (locale.isBogus()) {
+    result.setToBogus();
+    return result;
+  }
+  UnicodeString resultName;
+
+  const char* lang = locale.getLanguage();
+  if (uprv_strlen(lang) == 0) {
+    lang = "root";
+  }
+  const char* script = locale.getScript();
+  const char* country = locale.getCountry();
+  const char* variant = locale.getVariant();
+
+  UBool hasScript = uprv_strlen(script) > 0;
+  UBool hasCountry = uprv_strlen(country) > 0;
+  UBool hasVariant = uprv_strlen(variant) > 0;
+
+  if (dialectHandling == ULDN_DIALECT_NAMES) {
+    char buffer[ULOC_FULLNAME_CAPACITY];
+    do { // loop construct is so we can break early out of search
+      if (hasScript && hasCountry) {
+        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, "_", country, (char *)0);
+        localeIdName(buffer, resultName);
+        if (!resultName.isBogus()) {
+          hasScript = FALSE;
+          hasCountry = FALSE;
+          break;
+        }
+      }
+      if (hasScript) {
+        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, (char *)0);
+        localeIdName(buffer, resultName);
+        if (!resultName.isBogus()) {
+          hasScript = FALSE;
+          break;
+        }
+      }
+      if (hasCountry) {
+        ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", country, (char*)0);
+        localeIdName(buffer, resultName);
+        if (!resultName.isBogus()) {
+          hasCountry = FALSE;
+          break;
+        }
+      }
+    } while (FALSE);
+  }
+  if (resultName.isBogus() || resultName.isEmpty()) {
+    localeIdName(lang, resultName);
+  }
+
+  UnicodeString resultRemainder;
+  UnicodeString temp;
+  UErrorCode status = U_ZERO_ERROR;
+
+  if (hasScript) {
+    resultRemainder.append(scriptDisplayName(script, temp, TRUE));
+  }
+  if (hasCountry) {
+    appendWithSep(resultRemainder, regionDisplayName(country, temp, TRUE));
+  }
+  if (hasVariant) {
+    appendWithSep(resultRemainder, variantDisplayName(variant, temp, TRUE));
+  }
+  resultRemainder.findAndReplace(formatOpenParen, formatReplaceOpenParen);
+  resultRemainder.findAndReplace(formatCloseParen, formatReplaceCloseParen);
+
+  LocalPointer<StringEnumeration> e(locale.createKeywords(status));
+  if (e.isValid() && U_SUCCESS(status)) {
+    UnicodeString temp2;
+    char value[ULOC_KEYWORD_AND_VALUES_CAPACITY]; // sigh, no ULOC_VALUE_CAPACITY
+    const char* key;
+    while ((key = e->next((int32_t *)0, status)) != NULL) {
+      locale.getKeywordValue(key, value, ULOC_KEYWORD_AND_VALUES_CAPACITY, status);
+      if (U_FAILURE(status)) {
+        return result;
+      }
+      keyDisplayName(key, temp, TRUE);
+      temp.findAndReplace(formatOpenParen, formatReplaceOpenParen);
+      temp.findAndReplace(formatCloseParen, formatReplaceCloseParen);
+      keyValueDisplayName(key, value, temp2, TRUE);
+      temp2.findAndReplace(formatOpenParen, formatReplaceOpenParen);
+      temp2.findAndReplace(formatCloseParen, formatReplaceCloseParen);
+      if (temp2 != UnicodeString(value, -1, US_INV)) {
+        appendWithSep(resultRemainder, temp2);
+      } else if (temp != UnicodeString(key, -1, US_INV)) {
+        UnicodeString temp3;
+        keyTypeFormat.format(temp, temp2, temp3, status);
+        appendWithSep(resultRemainder, temp3);
+      } else {
+        appendWithSep(resultRemainder, temp)
+          .append((UChar)0x3d /* = */)
+          .append(temp2);
+      }
+    }
+  }
+
+  if (!resultRemainder.isEmpty()) {
+    format.format(resultName, resultRemainder, result.remove(), status);
+    return adjustForUsageAndContext(kCapContextUsageLanguage, result);
+  }
+
+  result = resultName;
+  return adjustForUsageAndContext(kCapContextUsageLanguage, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::appendWithSep(UnicodeString& buffer, const UnicodeString& src) const {
+    if (buffer.isEmpty()) {
+        buffer.setTo(src);
+    } else {
+        const UnicodeString *values[2] = { &buffer, &src };
+        UErrorCode status = U_ZERO_ERROR;
+        separatorFormat.formatAndReplace(values, 2, buffer, NULL, 0, status);
+    }
+    return buffer;
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::localeDisplayName(const char* localeId,
+                                          UnicodeString& result) const {
+    return localeDisplayName(Locale(localeId), result);
+}
+
+// private
+UnicodeString&
+LocaleDisplayNamesImpl::localeIdName(const char* localeId,
+                                     UnicodeString& result) const {
+    if (nameLength == UDISPCTX_LENGTH_SHORT) {
+        langData.getNoFallback("Languages%short", localeId, result);
+        if (!result.isBogus()) {
+            return result;
+        }
+    }
+    return langData.getNoFallback("Languages", localeId, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::languageDisplayName(const char* lang,
+                                            UnicodeString& result) const {
+    if (uprv_strcmp("root", lang) == 0 || uprv_strchr(lang, '_') != NULL) {
+        return result = UnicodeString(lang, -1, US_INV);
+    }
+    if (nameLength == UDISPCTX_LENGTH_SHORT) {
+        langData.get("Languages%short", lang, result);
+        if (!result.isBogus()) {
+            return adjustForUsageAndContext(kCapContextUsageLanguage, result);
+        }
+    }
+    langData.get("Languages", lang, result);
+    return adjustForUsageAndContext(kCapContextUsageLanguage, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
+                                          UnicodeString& result,
+                                          UBool skipAdjust) const {
+    if (nameLength == UDISPCTX_LENGTH_SHORT) {
+        langData.get("Scripts%short", script, result);
+        if (!result.isBogus()) {
+            return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageScript, result);
+        }
+    }
+    langData.get("Scripts", script, result);
+    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageScript, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
+                                          UnicodeString& result) const {
+    return scriptDisplayName(script, result, FALSE);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::scriptDisplayName(UScriptCode scriptCode,
+                                          UnicodeString& result) const {
+    return scriptDisplayName(uscript_getName(scriptCode), result, FALSE);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::regionDisplayName(const char* region,
+                                          UnicodeString& result,
+                                          UBool skipAdjust) const {
+    if (nameLength == UDISPCTX_LENGTH_SHORT) {
+        regionData.get("Countries%short", region, result);
+        if (!result.isBogus()) {
+            return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageTerritory, result);
+        }
+    }
+    regionData.get("Countries", region, result);
+    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageTerritory, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::regionDisplayName(const char* region,
+                                          UnicodeString& result) const {
+    return regionDisplayName(region, result, FALSE);
+}
+
+
+UnicodeString&
+LocaleDisplayNamesImpl::variantDisplayName(const char* variant,
+                                           UnicodeString& result,
+                                           UBool skipAdjust) const {
+    // don't have a resource for short variant names
+    langData.get("Variants", variant, result);
+    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageVariant, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::variantDisplayName(const char* variant,
+                                           UnicodeString& result) const {
+    return variantDisplayName(variant, result, FALSE);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::keyDisplayName(const char* key,
+                                       UnicodeString& result,
+                                       UBool skipAdjust) const {
+    // don't have a resource for short key names
+    langData.get("Keys", key, result);
+    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKey, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::keyDisplayName(const char* key,
+                                       UnicodeString& result) const {
+    return keyDisplayName(key, result, FALSE);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
+                                            const char* value,
+                                            UnicodeString& result,
+                                            UBool skipAdjust) const {
+    if (uprv_strcmp(key, "currency") == 0) {
+        // ICU4C does not have ICU4J CurrencyDisplayInfo equivalent for now.
+        UErrorCode sts = U_ZERO_ERROR;
+        UnicodeString ustrValue(value, -1, US_INV);
+        int32_t len;
+        UBool isChoice = FALSE;
+        const UChar *currencyName = ucurr_getName(ustrValue.getTerminatedBuffer(),
+            locale.getBaseName(), UCURR_LONG_NAME, &isChoice, &len, &sts);
+        if (U_FAILURE(sts)) {
+            // Return the value as is on failure
+            result = ustrValue;
+            return result;
+        }
+        result.setTo(currencyName, len);
+        return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);
+    }
+
+    if (nameLength == UDISPCTX_LENGTH_SHORT) {
+        langData.get("Types%short", key, value, result);
+        if (!result.isBogus()) {
+            return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);
+        }
+    }
+    langData.get("Types", key, value, result);
+    return skipAdjust? result: adjustForUsageAndContext(kCapContextUsageKeyValue, result);
+}
+
+UnicodeString&
+LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
+                                            const char* value,
+                                            UnicodeString& result) const {
+    return keyValueDisplayName(key, value, result, FALSE);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+LocaleDisplayNames*
+LocaleDisplayNames::createInstance(const Locale& locale,
+                                   UDialectHandling dialectHandling) {
+    return new LocaleDisplayNamesImpl(locale, dialectHandling);
+}
+
+LocaleDisplayNames*
+LocaleDisplayNames::createInstance(const Locale& locale,
+                                   UDisplayContext *contexts, int32_t length) {
+    if (contexts == NULL) {
+        length = 0;
+    }
+    return new LocaleDisplayNamesImpl(locale, contexts, length);
+}
+
+U_NAMESPACE_END
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+U_NAMESPACE_USE
+
+U_CAPI ULocaleDisplayNames * U_EXPORT2
+uldn_open(const char * locale,
+          UDialectHandling dialectHandling,
+          UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (locale == NULL) {
+    locale = uloc_getDefault();
+  }
+  return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), dialectHandling);
+}
+
+U_CAPI ULocaleDisplayNames * U_EXPORT2
+uldn_openForContext(const char * locale,
+                    UDisplayContext *contexts, int32_t length,
+                    UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (locale == NULL) {
+    locale = uloc_getDefault();
+  }
+  return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), contexts, length);
+}
+
+
+U_CAPI void U_EXPORT2
+uldn_close(ULocaleDisplayNames *ldn) {
+  delete (LocaleDisplayNames *)ldn;
+}
+
+U_CAPI const char * U_EXPORT2
+uldn_getLocale(const ULocaleDisplayNames *ldn) {
+  if (ldn) {
+    return ((const LocaleDisplayNames *)ldn)->getLocale().getName();
+  }
+  return NULL;
+}
+
+U_CAPI UDialectHandling U_EXPORT2
+uldn_getDialectHandling(const ULocaleDisplayNames *ldn) {
+  if (ldn) {
+    return ((const LocaleDisplayNames *)ldn)->getDialectHandling();
+  }
+  return ULDN_STANDARD_NAMES;
+}
+
+U_CAPI UDisplayContext U_EXPORT2
+uldn_getContext(const ULocaleDisplayNames *ldn,
+              UDisplayContextType type,
+              UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return (UDisplayContext)0;
+  }
+  return ((const LocaleDisplayNames *)ldn)->getContext(type);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
+                       const char *locale,
+                       UChar *result,
+                       int32_t maxResultSize,
+                       UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || locale == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->localeDisplayName(locale, temp);
+  if (temp.isBogus()) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
+                         const char *lang,
+                         UChar *result,
+                         int32_t maxResultSize,
+                         UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || lang == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->languageDisplayName(lang, temp);
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
+                       const char *script,
+                       UChar *result,
+                       int32_t maxResultSize,
+                       UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || script == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->scriptDisplayName(script, temp);
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
+                           UScriptCode scriptCode,
+                           UChar *result,
+                           int32_t maxResultSize,
+                           UErrorCode *pErrorCode) {
+  return uldn_scriptDisplayName(ldn, uscript_getName(scriptCode), result, maxResultSize, pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
+                       const char *region,
+                       UChar *result,
+                       int32_t maxResultSize,
+                       UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || region == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->regionDisplayName(region, temp);
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
+                        const char *variant,
+                        UChar *result,
+                        int32_t maxResultSize,
+                        UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || variant == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->variantDisplayName(variant, temp);
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
+                    const char *key,
+                    UChar *result,
+                    int32_t maxResultSize,
+                    UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || key == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->keyDisplayName(key, temp);
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+U_CAPI int32_t U_EXPORT2
+uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
+                         const char *key,
+                         const char *value,
+                         UChar *result,
+                         int32_t maxResultSize,
+                         UErrorCode *pErrorCode) {
+  if (U_FAILURE(*pErrorCode)) {
+    return 0;
+  }
+  if (ldn == NULL || key == NULL || value == NULL || (result == NULL && maxResultSize > 0)
+      || maxResultSize < 0) {
+    *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
+    return 0;
+  }
+  UnicodeString temp(result, 0, maxResultSize);
+  ((const LocaleDisplayNames *)ldn)->keyValueDisplayName(key, value, temp);
+  return temp.extract(result, maxResultSize, *pErrorCode);
+}
+
+#endif