icuSources/i18n/locdspnm.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2010-2012, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include "unicode/locdspnm.h"
  13 #include "unicode/msgfmt.h"
  14 #include "unicode/ures.h"
  15 #include "unicode/brkiter.h"
  16
  17 #include "cmemory.h"
  18 #include "cstring.h"
  19 #include "ulocimp.h"
  20 #include "ureslocs.h"
  21 #include "uresimp.h"
  22
  23 #include <stdarg.h>
  24
  25 /**
  26  * Concatenate a number of null-terminated strings to buffer, leaving a
  27  * null-terminated string.  The last argument should be the null pointer.
  28  * Return the length of the string in the buffer, not counting the trailing
  29  * null.  Return -1 if there is an error (buffer is null, or buflen < 1).
  30  */
  31 static int32_t ncat(char *buffer, uint32_t buflen, ...) {
  32   va_list args;
  33   char *str;
  34   char *p = buffer;
  35   const char* e = buffer + buflen - 1;
  36
  37   if (buffer == NULL || buflen < 1) {
  38     return -1;
  39   }
  40
  41   va_start(args, buflen);
  42   while ((str = va_arg(args, char *))) {
  43     char c;
  44     while (p != e && (c = *str++)) {
  45       *p++ = c;
  46     }
  47   }
  48   *p = 0;
  49   va_end(args);
  50
  51   return p - buffer;
  52 }
  53
  54 U_NAMESPACE_BEGIN
  55
  56 ////////////////////////////////////////////////////////////////////////////////////////////////////
  57
  58 // Access resource data for locale components.
  59 // Wrap code in uloc.c for now.
  60 class ICUDataTable {
  61     const char* path;
  62     Locale locale;
  63
  64 public:
  65     ICUDataTable(const char* path, const Locale& locale);
  66     ~ICUDataTable();
  67
  68     const Locale& getLocale();
  69
  70     UnicodeString& get(const char* tableKey, const char* itemKey,
  71                         UnicodeString& result) const;
  72     UnicodeString& get(const char* tableKey, const char* subTableKey, const char* itemKey,
  73                         UnicodeString& result) const;
  74
  75     UnicodeString& getNoFallback(const char* tableKey, const char* itemKey,
  76                                 UnicodeString &result) const;
  77     UnicodeString& getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
  78                                 UnicodeString &result) const;
  79 };
  80
  81 inline UnicodeString &
  82 ICUDataTable::get(const char* tableKey, const char* itemKey, UnicodeString& result) const {
  83     return get(tableKey, NULL, itemKey, result);
  84 }
  85
  86 inline UnicodeString &
  87 ICUDataTable::getNoFallback(const char* tableKey, const char* itemKey, UnicodeString& result) const {
  88     return getNoFallback(tableKey, NULL, itemKey, result);
  89 }
  90
  91 ICUDataTable::ICUDataTable(const char* path, const Locale& locale)
  92     : path(NULL), locale(Locale::getRoot())
  93 {
  94   if (path) {
  95     int32_t len = uprv_strlen(path);
  96     this->path = (const char*) uprv_malloc(len + 1);
  97     if (this->path) {
  98       uprv_strcpy((char *)this->path, path);
  99       this->locale = locale;
 100     }
 101   }
 102 }
 103
 104 ICUDataTable::~ICUDataTable() {
 105   if (path) {
 106     uprv_free((void*) path);
 107     path = NULL;
 108   }
 109 }
 110
 111 const Locale&
 112 ICUDataTable::getLocale() {
 113   return locale;
 114 }
 115
 116 UnicodeString &
 117 ICUDataTable::get(const char* tableKey, const char* subTableKey, const char* itemKey,
 118                   UnicodeString &result) const {
 119   UErrorCode status = U_ZERO_ERROR;
 120   int32_t len = 0;
 121
 122   const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
 123                                                    tableKey, subTableKey, itemKey,
 124                                                    &len, &status);
 125   if (U_SUCCESS(status) && len > 0) {
 126     return result.setTo(s, len);
 127   }
 128   return result.setTo(UnicodeString(itemKey, -1, US_INV));
 129 }
 130
 131 UnicodeString &
 132 ICUDataTable::getNoFallback(const char* tableKey, const char* subTableKey, const char* itemKey,
 133                             UnicodeString& result) const {
 134   UErrorCode status = U_ZERO_ERROR;
 135   int32_t len = 0;
 136
 137   const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
 138                                                    tableKey, subTableKey, itemKey,
 139                                                    &len, &status);
 140   if (U_SUCCESS(status)) {
 141     return result.setTo(s, len);
 142   }
 143
 144   result.setToBogus();
 145   return result;
 146 }
 147
 148 ////////////////////////////////////////////////////////////////////////////////////////////////////
 149
 150 LocaleDisplayNames::~LocaleDisplayNames() {}
 151
 152 ////////////////////////////////////////////////////////////////////////////////////////////////////
 153
 154 #if 0  // currently unused
 155
 156 class DefaultLocaleDisplayNames : public LocaleDisplayNames {
 157   UDialectHandling dialectHandling;
 158
 159 public:
 160   // constructor
 161   DefaultLocaleDisplayNames(UDialectHandling dialectHandling);
 162
 163   virtual ~DefaultLocaleDisplayNames();
 164
 165   virtual const Locale& getLocale() const;
 166   virtual UDialectHandling getDialectHandling() const;
 167
 168   virtual UnicodeString& localeDisplayName(const Locale& locale,
 169                                            UnicodeString& result) const;
 170   virtual UnicodeString& localeDisplayName(const char* localeId,
 171                                            UnicodeString& result) const;
 172   virtual UnicodeString& languageDisplayName(const char* lang,
 173                                              UnicodeString& result) const;
 174   virtual UnicodeString& scriptDisplayName(const char* script,
 175                                            UnicodeString& result) const;
 176   virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
 177                                            UnicodeString& result) const;
 178   virtual UnicodeString& regionDisplayName(const char* region,
 179                                            UnicodeString& result) const;
 180   virtual UnicodeString& variantDisplayName(const char* variant,
 181                                             UnicodeString& result) const;
 182   virtual UnicodeString& keyDisplayName(const char* key,
 183                                         UnicodeString& result) const;
 184   virtual UnicodeString& keyValueDisplayName(const char* key,
 185                                              const char* value,
 186                                              UnicodeString& result) const;
 187 };
 188
 189 DefaultLocaleDisplayNames::DefaultLocaleDisplayNames(UDialectHandling dialectHandling)
 190     : dialectHandling(dialectHandling) {
 191 }
 192
 193 DefaultLocaleDisplayNames::~DefaultLocaleDisplayNames() {
 194 }
 195
 196 const Locale&
 197 DefaultLocaleDisplayNames::getLocale() const {
 198   return Locale::getRoot();
 199 }
 200
 201 UDialectHandling
 202 DefaultLocaleDisplayNames::getDialectHandling() const {
 203   return dialectHandling;
 204 }
 205
 206 UnicodeString&
 207 DefaultLocaleDisplayNames::localeDisplayName(const Locale& locale,
 208                                              UnicodeString& result) const {
 209   return result = UnicodeString(locale.getName(), -1, US_INV);
 210 }
 211
 212 UnicodeString&
 213 DefaultLocaleDisplayNames::localeDisplayName(const char* localeId,
 214                                              UnicodeString& result) const {
 215   return result = UnicodeString(localeId, -1, US_INV);
 216 }
 217
 218 UnicodeString&
 219 DefaultLocaleDisplayNames::languageDisplayName(const char* lang,
 220                                                UnicodeString& result) const {
 221   return result = UnicodeString(lang, -1, US_INV);
 222 }
 223
 224 UnicodeString&
 225 DefaultLocaleDisplayNames::scriptDisplayName(const char* script,
 226                                              UnicodeString& result) const {
 227   return result = UnicodeString(script, -1, US_INV);
 228 }
 229
 230 UnicodeString&
 231 DefaultLocaleDisplayNames::scriptDisplayName(UScriptCode scriptCode,
 232                                              UnicodeString& result) const {
 233   const char* name = uscript_getName(scriptCode);
 234   if (name) {
 235     return result = UnicodeString(name, -1, US_INV);
 236   }
 237   return result.remove();
 238 }
 239
 240 UnicodeString&
 241 DefaultLocaleDisplayNames::regionDisplayName(const char* region,
 242                                              UnicodeString& result) const {
 243   return result = UnicodeString(region, -1, US_INV);
 244 }
 245
 246 UnicodeString&
 247 DefaultLocaleDisplayNames::variantDisplayName(const char* variant,
 248                                               UnicodeString& result) const {
 249   return result = UnicodeString(variant, -1, US_INV);
 250 }
 251
 252 UnicodeString&
 253 DefaultLocaleDisplayNames::keyDisplayName(const char* key,
 254                                           UnicodeString& result) const {
 255   return result = UnicodeString(key, -1, US_INV);
 256 }
 257
 258 UnicodeString&
 259 DefaultLocaleDisplayNames::keyValueDisplayName(const char* /* key */,
 260                                                const char* value,
 261                                                UnicodeString& result) const {
 262   return result = UnicodeString(value, -1, US_INV);
 263 }
 264
 265 #endif  // currently unused class DefaultLocaleDisplayNames
 266
 267 ////////////////////////////////////////////////////////////////////////////////////////////////////
 268
 269 class LocaleDisplayNamesImpl : public LocaleDisplayNames {
 270     Locale locale;
 271     UDialectHandling dialectHandling;
 272     ICUDataTable langData;
 273     ICUDataTable regionData;
 274     UnicodeString sep;
 275     MessageFormat *format;
 276     MessageFormat *keyTypeFormat;
 277     UDisplayContext capitalizationContext;
 278
 279     // Constants for capitalization context usage types.
 280     enum CapContextUsage {
 281         kCapContextUsageLanguage,
 282         kCapContextUsageScript,
 283         kCapContextUsageTerritory,
 284         kCapContextUsageVariant,
 285         kCapContextUsageKey,
 286         kCapContextUsageType,
 287         kCapContextUsageCount
 288     };
 289     // Capitalization transforms. For each usage type, the first array element indicates
 290     // whether to titlecase for uiListOrMenu context, the second indicates whether to
 291     // titlecase for stand-alone context.
 292      UBool fCapitalization[kCapContextUsageCount][2];
 293
 294 public:
 295     // constructor
 296     LocaleDisplayNamesImpl(const Locale& locale, UDialectHandling dialectHandling);
 297     LocaleDisplayNamesImpl(const Locale& locale, UDisplayContext *contexts, int32_t length);
 298     virtual ~LocaleDisplayNamesImpl();
 299
 300     virtual const Locale& getLocale() const;
 301     virtual UDialectHandling getDialectHandling() const;
 302     virtual UDisplayContext getContext(UDisplayContextType type) const;
 303
 304     virtual UnicodeString& localeDisplayName(const Locale& locale,
 305                                                 UnicodeString& result) const;
 306     virtual UnicodeString& localeDisplayName(const char* localeId,
 307                                                 UnicodeString& result) const;
 308     virtual UnicodeString& languageDisplayName(const char* lang,
 309                                                UnicodeString& result) const;
 310     virtual UnicodeString& scriptDisplayName(const char* script,
 311                                                 UnicodeString& result) const;
 312     virtual UnicodeString& scriptDisplayName(UScriptCode scriptCode,
 313                                                 UnicodeString& result) const;
 314     virtual UnicodeString& regionDisplayName(const char* region,
 315                                                 UnicodeString& result) const;
 316     virtual UnicodeString& variantDisplayName(const char* variant,
 317                                                 UnicodeString& result) const;
 318     virtual UnicodeString& keyDisplayName(const char* key,
 319                                                 UnicodeString& result) const;
 320     virtual UnicodeString& keyValueDisplayName(const char* key,
 321                                                 const char* value,
 322                                                 UnicodeString& result) const;
 323 private:
 324     UnicodeString& localeIdName(const char* localeId,
 325                                 UnicodeString& result) const;
 326     UnicodeString& appendWithSep(UnicodeString& buffer, const UnicodeString& src) const;
 327     UnicodeString& adjustForUsageAndContext(CapContextUsage usage, UnicodeString& result) const;
 328     void initialize(void);
 329 };
 330
 331 LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
 332                                                UDialectHandling dialectHandling)
 333     : dialectHandling(dialectHandling)
 334     , langData(U_ICUDATA_LANG, locale)
 335     , regionData(U_ICUDATA_REGION, locale)
 336     , format(NULL)
 337     , keyTypeFormat(NULL)
 338     , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 339 {
 340     initialize();
 341 }
 342
 343 LocaleDisplayNamesImpl::LocaleDisplayNamesImpl(const Locale& locale,
 344                                                UDisplayContext *contexts, int32_t length)
 345     : dialectHandling(ULDN_STANDARD_NAMES)
 346     , langData(U_ICUDATA_LANG, locale)
 347     , regionData(U_ICUDATA_REGION, locale)
 348     , format(NULL)
 349     , keyTypeFormat(NULL)
 350     , capitalizationContext(UDISPCTX_CAPITALIZATION_NONE)
 351 {
 352     while (length-- > 0) {
 353         UDisplayContext value = *contexts++;
 354         UDisplayContextType selector = (UDisplayContextType)((uint32_t)value >> 8);
 355         switch (selector) {
 356             case UDISPCTX_TYPE_DIALECT_HANDLING:
 357                 dialectHandling = (UDialectHandling)value;
 358                 break;
 359             case UDISPCTX_TYPE_CAPITALIZATION:
 360                 capitalizationContext = value;
 361                 break;
 362             default:
 363                 break;
 364         }
 365     }
 366     initialize();
 367 }
 368
 369 void
 370 LocaleDisplayNamesImpl::initialize(void) {
 371     LocaleDisplayNamesImpl *nonConstThis = (LocaleDisplayNamesImpl *)this;
 372     nonConstThis->locale = langData.getLocale() == Locale::getRoot()
 373         ? regionData.getLocale()
 374         : langData.getLocale();
 375
 376     langData.getNoFallback("localeDisplayPattern", "separator", sep);
 377     if (sep.isBogus()) {
 378         sep = UnicodeString(", ", -1, US_INV);
 379     }
 380
 381     UnicodeString pattern;
 382     langData.getNoFallback("localeDisplayPattern", "pattern", pattern);
 383     if (pattern.isBogus()) {
 384         pattern = UnicodeString("{0} ({1})", -1, US_INV);
 385     }
 386     UErrorCode status = U_ZERO_ERROR;
 387     format = new MessageFormat(pattern, status);
 388
 389     UnicodeString ktPattern;
 390     langData.get("localeDisplayPattern", "keyTypePattern", ktPattern);
 391     if (ktPattern.isBogus()) {
 392         ktPattern = UnicodeString("{0}={1}", -1, US_INV);
 393     }
 394     keyTypeFormat = new MessageFormat(ktPattern, status);
 395
 396     uprv_memset(fCapitalization, 0, sizeof(fCapitalization));
 397 #if !UCONFIG_NO_BREAK_ITERATION
 398     // The following is basically copied from DateFormatSymbols::initializeData
 399     typedef struct {
 400         const char * usageName;
 401         LocaleDisplayNamesImpl::CapContextUsage usageEnum;
 402     } ContextUsageNameToEnum;
 403     const ContextUsageNameToEnum contextUsageTypeMap[] = {
 404        // Entries must be sorted by usageTypeName; entry with NULL name terminates list.
 405         { "key",        kCapContextUsageKey },
 406         { "languages",  kCapContextUsageLanguage },
 407         { "script",     kCapContextUsageScript },
 408         { "territory",  kCapContextUsageTerritory },
 409         { "type",       kCapContextUsageType },
 410         { "variant",    kCapContextUsageVariant },
 411         { NULL,         (CapContextUsage)0 },
 412     };
 413     int32_t len = 0;
 414     UResourceBundle *localeBundle = ures_open(NULL, locale.getName(), &status);
 415     if (U_SUCCESS(status)) {
 416         UResourceBundle *contextTransforms = ures_getByKeyWithFallback(localeBundle, "contextTransforms", NULL, &status);
 417         if (U_SUCCESS(status)) {
 418             UResourceBundle *contextTransformUsage;
 419             while ( (contextTransformUsage = ures_getNextResource(contextTransforms, NULL, &status)) != NULL ) {
 420                 const int32_t * intVector = ures_getIntVector(contextTransformUsage, &len, &status);
 421                 if (U_SUCCESS(status) && intVector != NULL && len >= 2) {
 422                     const char* usageKey = ures_getKey(contextTransformUsage);
 423                     if (usageKey != NULL) {
 424                         const ContextUsageNameToEnum * typeMapPtr = contextUsageTypeMap;
 425                         int32_t compResult = 0;
 426                         // linear search; list is short and we cannot be sure that bsearch is available
 427                         while ( typeMapPtr->usageName != NULL && (compResult = uprv_strcmp(usageKey, typeMapPtr->usageName)) > 0 ) {
 428                             ++typeMapPtr;
 429                         }
 430                         if (typeMapPtr->usageName != NULL && compResult == 0) {
 431                             fCapitalization[typeMapPtr->usageEnum][0] = intVector[0];
 432                             fCapitalization[typeMapPtr->usageEnum][1] = intVector[1];
 433                         }
 434                     }
 435                 }
 436                 status = U_ZERO_ERROR;
 437                 ures_close(contextTransformUsage);
 438             }
 439             ures_close(contextTransforms);
 440         }
 441         ures_close(localeBundle);
 442     }
 443 #endif
 444 }
 445
 446 LocaleDisplayNamesImpl::~LocaleDisplayNamesImpl() {
 447     delete format;
 448     delete keyTypeFormat;
 449  }
 450
 451 const Locale&
 452 LocaleDisplayNamesImpl::getLocale() const {
 453     return locale;
 454 }
 455
 456 UDialectHandling
 457 LocaleDisplayNamesImpl::getDialectHandling() const {
 458     return dialectHandling;
 459 }
 460
 461 UDisplayContext
 462 LocaleDisplayNamesImpl::getContext(UDisplayContextType type) const {
 463     switch (type) {
 464         case UDISPCTX_TYPE_DIALECT_HANDLING:
 465             return (UDisplayContext)dialectHandling;
 466         case UDISPCTX_TYPE_CAPITALIZATION:
 467             return capitalizationContext;
 468         default:
 469             break;
 470     }
 471     return (UDisplayContext)0;
 472 }
 473
 474 UnicodeString&
 475 LocaleDisplayNamesImpl::adjustForUsageAndContext(CapContextUsage usage,
 476                                                 UnicodeString& result) const {
 477 #if !UCONFIG_NO_BREAK_ITERATION
 478     // check to see whether we need to titlecase result
 479     UBool titlecase = FALSE;
 480     switch (capitalizationContext) {
 481         case UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE:
 482             titlecase = TRUE;
 483             break;
 484         case UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU:
 485             titlecase = fCapitalization[usage][0];
 486             break;
 487         case UDISPCTX_CAPITALIZATION_FOR_STANDALONE:
 488             titlecase = fCapitalization[usage][1];
 489             break;
 490         default:
 491             // titlecase = FALSE;
 492             break;
 493     }
 494     if (titlecase) {
 495         // TODO: Fix this titlecase hack when we figure out something better to do.
 496         // We don't want to titlecase the whole text, only something like the first word,
 497         // of the first segment long enough to have a complete cluster, whichever is
 498         // shorter. We could have keep a word break iterator around, but I am not sure
 499         // that will do the ight thing for the purposes here. For now we assume that in
 500         // languages for which titlecasing makes a difference, we can stop at non-letter
 501         // characters in 0x0000-0x00FF and only titlecase up to the first occurrence of
 502         // any of those, or to a small number of chars, whichever comes first.
 503         int32_t stopPos, stopPosLimit = 8, len = result.length();
 504         if ( stopPosLimit > len ) {
 505             stopPosLimit = len;
 506         }
 507         for ( stopPos = 0; stopPos < stopPosLimit; stopPos++ ) {
 508             UChar32 ch = result.char32At(stopPos);
 509             if ( (ch < 0x41) || (ch > 0x5A && ch < 0x61) || (ch > 0x7A && ch < 0xC0) ) {
 510                 break;
 511             }
 512             if (ch >= 0x10000) {
 513                 stopPos++;
 514             }
 515         }
 516         if ( stopPos > 0 && stopPos < len ) {
 517             UnicodeString firstWord(result, 0, stopPos);
 518             firstWord.toTitle(NULL, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
 519             result.replaceBetween(0, stopPos, firstWord);
 520         } else {
 521             // no stopPos, titlecase the whole text
 522             result.toTitle(NULL, locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
 523         }
 524     }
 525 #endif
 526     return result;
 527 }
 528
 529 UnicodeString&
 530 LocaleDisplayNamesImpl::localeDisplayName(const Locale& locale,
 531                                           UnicodeString& result) const {
 532   UnicodeString resultName;
 533
 534   const char* lang = locale.getLanguage();
 535   if (uprv_strlen(lang) == 0) {
 536     lang = "root";
 537   }
 538   const char* script = locale.getScript();
 539   const char* country = locale.getCountry();
 540   const char* variant = locale.getVariant();
 541
 542   UBool hasScript = uprv_strlen(script) > 0;
 543   UBool hasCountry = uprv_strlen(country) > 0;
 544   UBool hasVariant = uprv_strlen(variant) > 0;
 545
 546   if (dialectHandling == ULDN_DIALECT_NAMES) {
 547     char buffer[ULOC_FULLNAME_CAPACITY];
 548     do { // loop construct is so we can break early out of search
 549       if (hasScript && hasCountry) {
 550         ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, "_", country, (char *)0);
 551         localeIdName(buffer, resultName);
 552         if (!resultName.isBogus()) {
 553           hasScript = FALSE;
 554           hasCountry = FALSE;
 555           break;
 556         }
 557       }
 558       if (hasScript) {
 559         ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", script, (char *)0);
 560         localeIdName(buffer, resultName);
 561         if (!resultName.isBogus()) {
 562           hasScript = FALSE;
 563           break;
 564         }
 565       }
 566       if (hasCountry) {
 567         ncat(buffer, ULOC_FULLNAME_CAPACITY, lang, "_", country, (char*)0);
 568         localeIdName(buffer, resultName);
 569         if (!resultName.isBogus()) {
 570           hasCountry = FALSE;
 571           break;
 572         }
 573       }
 574     } while (FALSE);
 575   }
 576   if (resultName.isBogus() || resultName.isEmpty()) {
 577     localeIdName(lang, resultName);
 578   }
 579
 580   UnicodeString resultRemainder;
 581   UnicodeString temp;
 582   StringEnumeration *e = NULL;
 583   UErrorCode status = U_ZERO_ERROR;
 584
 585   if (hasScript) {
 586     resultRemainder.append(scriptDisplayName(script, temp));
 587   }
 588   if (hasCountry) {
 589     appendWithSep(resultRemainder, regionDisplayName(country, temp));
 590   }
 591   if (hasVariant) {
 592     appendWithSep(resultRemainder, variantDisplayName(variant, temp));
 593   }
 594
 595   e = locale.createKeywords(status);
 596   if (e && U_SUCCESS(status)) {
 597     UnicodeString temp2;
 598     char value[ULOC_KEYWORD_AND_VALUES_CAPACITY]; // sigh, no ULOC_VALUE_CAPACITY
 599     const char* key;
 600     while ((key = e->next((int32_t *)0, status)) != NULL) {
 601       locale.getKeywordValue(key, value, ULOC_KEYWORD_AND_VALUES_CAPACITY, status);
 602       keyDisplayName(key, temp);
 603       keyValueDisplayName(key, value, temp2);
 604       if (temp2 != UnicodeString(value, -1, US_INV)) {
 605         appendWithSep(resultRemainder, temp2);
 606       } else if (temp != UnicodeString(key, -1, US_INV)) {
 607         UnicodeString temp3;
 608         Formattable data[] = {
 609           temp,
 610           temp2
 611         };
 612         FieldPosition fpos;
 613         status = U_ZERO_ERROR;
 614         keyTypeFormat->format(data, 2, temp3, fpos, status);
 615         appendWithSep(resultRemainder, temp3);
 616       } else {
 617         appendWithSep(resultRemainder, temp)
 618           .append((UChar)0x3d /* = */)
 619           .append(temp2);
 620       }
 621     }
 622     delete e;
 623   }
 624
 625   if (!resultRemainder.isEmpty()) {
 626     Formattable data[] = {
 627       resultName,
 628       resultRemainder
 629     };
 630     FieldPosition fpos;
 631     status = U_ZERO_ERROR;
 632     format->format(data, 2, result, fpos, status);
 633     return adjustForUsageAndContext(kCapContextUsageLanguage, result);
 634   }
 635
 636   result = resultName;
 637   return adjustForUsageAndContext(kCapContextUsageLanguage, result);
 638 }
 639
 640 UnicodeString&
 641 LocaleDisplayNamesImpl::appendWithSep(UnicodeString& buffer, const UnicodeString& src) const {
 642     if (!buffer.isEmpty()) {
 643         buffer.append(sep);
 644     }
 645     buffer.append(src);
 646     return buffer;
 647 }
 648
 649 UnicodeString&
 650 LocaleDisplayNamesImpl::localeDisplayName(const char* localeId,
 651                                           UnicodeString& result) const {
 652     return localeDisplayName(Locale(localeId), result);
 653 }
 654
 655 // private
 656 UnicodeString&
 657 LocaleDisplayNamesImpl::localeIdName(const char* localeId,
 658                                      UnicodeString& result) const {
 659     return langData.getNoFallback("Languages", localeId, result);
 660 }
 661
 662 UnicodeString&
 663 LocaleDisplayNamesImpl::languageDisplayName(const char* lang,
 664                                             UnicodeString& result) const {
 665     if (uprv_strcmp("root", lang) == 0 || uprv_strchr(lang, '_') != NULL) {
 666         return result = UnicodeString(lang, -1, US_INV);
 667     }
 668     langData.get("Languages", lang, result);
 669     return adjustForUsageAndContext(kCapContextUsageLanguage, result);
 670 }
 671
 672 UnicodeString&
 673 LocaleDisplayNamesImpl::scriptDisplayName(const char* script,
 674                                           UnicodeString& result) const {
 675     langData.get("Scripts", script, result);
 676     return adjustForUsageAndContext(kCapContextUsageScript, result);
 677 }
 678
 679 UnicodeString&
 680 LocaleDisplayNamesImpl::scriptDisplayName(UScriptCode scriptCode,
 681                                           UnicodeString& result) const {
 682     const char* name = uscript_getName(scriptCode);
 683     langData.get("Scripts", name, result);
 684     return adjustForUsageAndContext(kCapContextUsageScript, result);
 685 }
 686
 687 UnicodeString&
 688 LocaleDisplayNamesImpl::regionDisplayName(const char* region,
 689                                           UnicodeString& result) const {
 690     regionData.get("Countries", region, result);
 691     return adjustForUsageAndContext(kCapContextUsageTerritory, result);
 692 }
 693
 694 UnicodeString&
 695 LocaleDisplayNamesImpl::variantDisplayName(const char* variant,
 696                                            UnicodeString& result) const {
 697     langData.get("Variants", variant, result);
 698     return adjustForUsageAndContext(kCapContextUsageVariant, result);
 699 }
 700
 701 UnicodeString&
 702 LocaleDisplayNamesImpl::keyDisplayName(const char* key,
 703                                        UnicodeString& result) const {
 704     langData.get("Keys", key, result);
 705     return adjustForUsageAndContext(kCapContextUsageKey, result);
 706 }
 707
 708 UnicodeString&
 709 LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
 710                                             const char* value,
 711                                             UnicodeString& result) const {
 712     langData.get("Types", key, value, result);
 713     return adjustForUsageAndContext(kCapContextUsageType, result);
 714 }
 715
 716 ////////////////////////////////////////////////////////////////////////////////////////////////////
 717
 718 LocaleDisplayNames*
 719 LocaleDisplayNames::createInstance(const Locale& locale,
 720                                    UDialectHandling dialectHandling) {
 721     return new LocaleDisplayNamesImpl(locale, dialectHandling);
 722 }
 723
 724 LocaleDisplayNames*
 725 LocaleDisplayNames::createInstance(const Locale& locale,
 726                                    UDisplayContext *contexts, int32_t length) {
 727     if (contexts == NULL) {
 728         length = 0;
 729     }
 730     return new LocaleDisplayNamesImpl(locale, contexts, length);
 731 }
 732
 733 U_NAMESPACE_END
 734
 735 ////////////////////////////////////////////////////////////////////////////////////////////////////
 736
 737 U_NAMESPACE_USE
 738
 739 U_CAPI ULocaleDisplayNames * U_EXPORT2
 740 uldn_open(const char * locale,
 741           UDialectHandling dialectHandling,
 742           UErrorCode *pErrorCode) {
 743   if (U_FAILURE(*pErrorCode)) {
 744     return 0;
 745   }
 746   if (locale == NULL) {
 747     locale = uloc_getDefault();
 748   }
 749   return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), dialectHandling);
 750 }
 751
 752 U_CAPI ULocaleDisplayNames * U_EXPORT2
 753 uldn_openForContext(const char * locale,
 754                     UDisplayContext *contexts, int32_t length,
 755                     UErrorCode *pErrorCode) {
 756   if (U_FAILURE(*pErrorCode)) {
 757     return 0;
 758   }
 759   if (locale == NULL) {
 760     locale = uloc_getDefault();
 761   }
 762   return (ULocaleDisplayNames *)LocaleDisplayNames::createInstance(Locale(locale), contexts, length);
 763 }
 764
 765
 766 U_CAPI void U_EXPORT2
 767 uldn_close(ULocaleDisplayNames *ldn) {
 768   delete (LocaleDisplayNames *)ldn;
 769 }
 770
 771 U_CAPI const char * U_EXPORT2
 772 uldn_getLocale(const ULocaleDisplayNames *ldn) {
 773   if (ldn) {
 774     return ((const LocaleDisplayNames *)ldn)->getLocale().getName();
 775   }
 776   return NULL;
 777 }
 778
 779 U_CAPI UDialectHandling U_EXPORT2
 780 uldn_getDialectHandling(const ULocaleDisplayNames *ldn) {
 781   if (ldn) {
 782     return ((const LocaleDisplayNames *)ldn)->getDialectHandling();
 783   }
 784   return ULDN_STANDARD_NAMES;
 785 }
 786
 787 U_CAPI UDisplayContext U_EXPORT2
 788 uldn_getContext(const ULocaleDisplayNames *ldn,
 789               UDisplayContextType type,
 790               UErrorCode *pErrorCode) {
 791   if (U_FAILURE(*pErrorCode)) {
 792     return (UDisplayContext)0;
 793   }
 794   return ((const LocaleDisplayNames *)ldn)->getContext(type);
 795 }
 796
 797 U_CAPI int32_t U_EXPORT2
 798 uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
 799                        const char *locale,
 800                        UChar *result,
 801                        int32_t maxResultSize,
 802                        UErrorCode *pErrorCode) {
 803   if (U_FAILURE(*pErrorCode)) {
 804     return 0;
 805   }
 806   if (ldn == NULL || locale == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
 807     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 808     return 0;
 809   }
 810   UnicodeString temp(result, 0, maxResultSize);
 811   ((const LocaleDisplayNames *)ldn)->localeDisplayName(locale, temp);
 812   return temp.extract(result, maxResultSize, *pErrorCode);
 813 }
 814
 815 U_CAPI int32_t U_EXPORT2
 816 uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
 817                          const char *lang,
 818                          UChar *result,
 819                          int32_t maxResultSize,
 820                          UErrorCode *pErrorCode) {
 821   if (U_FAILURE(*pErrorCode)) {
 822     return 0;
 823   }
 824   if (ldn == NULL || lang == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
 825     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 826     return 0;
 827   }
 828   UnicodeString temp(result, 0, maxResultSize);
 829   ((const LocaleDisplayNames *)ldn)->languageDisplayName(lang, temp);
 830   return temp.extract(result, maxResultSize, *pErrorCode);
 831 }
 832
 833 U_CAPI int32_t U_EXPORT2
 834 uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
 835                        const char *script,
 836                        UChar *result,
 837                        int32_t maxResultSize,
 838                        UErrorCode *pErrorCode) {
 839   if (U_FAILURE(*pErrorCode)) {
 840     return 0;
 841   }
 842   if (ldn == NULL || script == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
 843     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 844     return 0;
 845   }
 846   UnicodeString temp(result, 0, maxResultSize);
 847   ((const LocaleDisplayNames *)ldn)->scriptDisplayName(script, temp);
 848   return temp.extract(result, maxResultSize, *pErrorCode);
 849 }
 850
 851 U_CAPI int32_t U_EXPORT2
 852 uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
 853                            UScriptCode scriptCode,
 854                            UChar *result,
 855                            int32_t maxResultSize,
 856                            UErrorCode *pErrorCode) {
 857   return uldn_scriptDisplayName(ldn, uscript_getName(scriptCode), result, maxResultSize, pErrorCode);
 858 }
 859
 860 U_CAPI int32_t U_EXPORT2
 861 uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
 862                        const char *region,
 863                        UChar *result,
 864                        int32_t maxResultSize,
 865                        UErrorCode *pErrorCode) {
 866   if (U_FAILURE(*pErrorCode)) {
 867     return 0;
 868   }
 869   if (ldn == NULL || region == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
 870     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 871     return 0;
 872   }
 873   UnicodeString temp(result, 0, maxResultSize);
 874   ((const LocaleDisplayNames *)ldn)->regionDisplayName(region, temp);
 875   return temp.extract(result, maxResultSize, *pErrorCode);
 876 }
 877
 878 U_CAPI int32_t U_EXPORT2
 879 uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
 880                         const char *variant,
 881                         UChar *result,
 882                         int32_t maxResultSize,
 883                         UErrorCode *pErrorCode) {
 884   if (U_FAILURE(*pErrorCode)) {
 885     return 0;
 886   }
 887   if (ldn == NULL || variant == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
 888     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 889     return 0;
 890   }
 891   UnicodeString temp(result, 0, maxResultSize);
 892   ((const LocaleDisplayNames *)ldn)->variantDisplayName(variant, temp);
 893   return temp.extract(result, maxResultSize, *pErrorCode);
 894 }
 895
 896 U_CAPI int32_t U_EXPORT2
 897 uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
 898                     const char *key,
 899                     UChar *result,
 900                     int32_t maxResultSize,
 901                     UErrorCode *pErrorCode) {
 902   if (U_FAILURE(*pErrorCode)) {
 903     return 0;
 904   }
 905   if (ldn == NULL || key == NULL || (result == NULL && maxResultSize > 0) || maxResultSize < 0) {
 906     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 907     return 0;
 908   }
 909   UnicodeString temp(result, 0, maxResultSize);
 910   ((const LocaleDisplayNames *)ldn)->keyDisplayName(key, temp);
 911   return temp.extract(result, maxResultSize, *pErrorCode);
 912 }
 913
 914 U_CAPI int32_t U_EXPORT2
 915 uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
 916                          const char *key,
 917                          const char *value,
 918                          UChar *result,
 919                          int32_t maxResultSize,
 920                          UErrorCode *pErrorCode) {
 921   if (U_FAILURE(*pErrorCode)) {
 922     return 0;
 923   }
 924   if (ldn == NULL || key == NULL || value == NULL || (result == NULL && maxResultSize > 0)
 925       || maxResultSize < 0) {
 926     *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
 927     return 0;
 928   }
 929   UnicodeString temp(result, 0, maxResultSize);
 930   ((const LocaleDisplayNames *)ldn)->keyValueDisplayName(key, value, temp);
 931   return temp.extract(result, maxResultSize, *pErrorCode);
 932 }
 933
 934 #endif