icuSources/common/locdispnames.cpp

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 1997-2010, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  locdispnames.cpp
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2010feb25
  14 *   created by: Markus W. Scherer
  15 *
  16 *   Code for locale display names, separated out from other .cpp files
  17 *   that then do not depend on resource bundle code and display name data.
  18 */
  19
  20 #include "unicode/utypes.h"
  21 #include "unicode/brkiter.h"
  22 #include "unicode/locid.h"
  23 #include "unicode/uloc.h"
  24 #include "unicode/ures.h"
  25 #include "unicode/ustring.h"
  26 #include "cmemory.h"
  27 #include "cstring.h"
  28 #include "putilimp.h"
  29 #include "ulocimp.h"
  30 #include "uresimp.h"
  31 #include "ureslocs.h"
  32 #include "ustr_imp.h"
  33
  34 // C++ API ----------------------------------------------------------------- ***
  35
  36 U_NAMESPACE_BEGIN
  37
  38 UnicodeString&
  39 Locale::getDisplayLanguage(UnicodeString& dispLang) const
  40 {
  41     return this->getDisplayLanguage(getDefault(), dispLang);
  42 }
  43
  44 /*We cannot make any assumptions on the size of the output display strings
  45 * Yet, since we are calling through to a C API, we need to set limits on
  46 * buffer size. For all the following getDisplay functions we first attempt
  47 * to fill up a stack allocated buffer. If it is to small we heap allocated
  48 * the exact buffer we need copy it to the UnicodeString and delete it*/
  49
  50 UnicodeString&
  51 Locale::getDisplayLanguage(const Locale &displayLocale,
  52                            UnicodeString &result) const {
  53     UChar *buffer;
  54     UErrorCode errorCode=U_ZERO_ERROR;
  55     int32_t length;
  56
  57     buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
  58     if(buffer==0) {
  59         result.truncate(0);
  60         return result;
  61     }
  62
  63     length=uloc_getDisplayLanguage(fullName, displayLocale.fullName,
  64                                    buffer, result.getCapacity(),
  65                                    &errorCode);
  66     result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
  67
  68     if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
  69         buffer=result.getBuffer(length);
  70         if(buffer==0) {
  71             result.truncate(0);
  72             return result;
  73         }
  74         errorCode=U_ZERO_ERROR;
  75         length=uloc_getDisplayLanguage(fullName, displayLocale.fullName,
  76                                        buffer, result.getCapacity(),
  77                                        &errorCode);
  78         result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
  79     }
  80
  81     return result;
  82 }
  83
  84 UnicodeString&
  85 Locale::getDisplayScript(UnicodeString& dispScript) const
  86 {
  87     return this->getDisplayScript(getDefault(), dispScript);
  88 }
  89
  90 UnicodeString&
  91 Locale::getDisplayScript(const Locale &displayLocale,
  92                           UnicodeString &result) const {
  93     UChar *buffer;
  94     UErrorCode errorCode=U_ZERO_ERROR;
  95     int32_t length;
  96
  97     buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
  98     if(buffer==0) {
  99         result.truncate(0);
 100         return result;
 101     }
 102
 103     length=uloc_getDisplayScript(fullName, displayLocale.fullName,
 104                                   buffer, result.getCapacity(),
 105                                   &errorCode);
 106     result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 107
 108     if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
 109         buffer=result.getBuffer(length);
 110         if(buffer==0) {
 111             result.truncate(0);
 112             return result;
 113         }
 114         errorCode=U_ZERO_ERROR;
 115         length=uloc_getDisplayScript(fullName, displayLocale.fullName,
 116                                       buffer, result.getCapacity(),
 117                                       &errorCode);
 118         result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 119     }
 120
 121     return result;
 122 }
 123
 124 UnicodeString&
 125 Locale::getDisplayCountry(UnicodeString& dispCntry) const
 126 {
 127     return this->getDisplayCountry(getDefault(), dispCntry);
 128 }
 129
 130 UnicodeString&
 131 Locale::getDisplayCountry(const Locale &displayLocale,
 132                           UnicodeString &result) const {
 133     UChar *buffer;
 134     UErrorCode errorCode=U_ZERO_ERROR;
 135     int32_t length;
 136
 137     buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
 138     if(buffer==0) {
 139         result.truncate(0);
 140         return result;
 141     }
 142
 143     length=uloc_getDisplayCountry(fullName, displayLocale.fullName,
 144                                   buffer, result.getCapacity(),
 145                                   &errorCode);
 146     result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 147
 148     if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
 149         buffer=result.getBuffer(length);
 150         if(buffer==0) {
 151             result.truncate(0);
 152             return result;
 153         }
 154         errorCode=U_ZERO_ERROR;
 155         length=uloc_getDisplayCountry(fullName, displayLocale.fullName,
 156                                       buffer, result.getCapacity(),
 157                                       &errorCode);
 158         result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 159     }
 160
 161     return result;
 162 }
 163
 164 UnicodeString&
 165 Locale::getDisplayVariant(UnicodeString& dispVar) const
 166 {
 167     return this->getDisplayVariant(getDefault(), dispVar);
 168 }
 169
 170 UnicodeString&
 171 Locale::getDisplayVariant(const Locale &displayLocale,
 172                           UnicodeString &result) const {
 173     UChar *buffer;
 174     UErrorCode errorCode=U_ZERO_ERROR;
 175     int32_t length;
 176
 177     buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
 178     if(buffer==0) {
 179         result.truncate(0);
 180         return result;
 181     }
 182
 183     length=uloc_getDisplayVariant(fullName, displayLocale.fullName,
 184                                   buffer, result.getCapacity(),
 185                                   &errorCode);
 186     result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 187
 188     if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
 189         buffer=result.getBuffer(length);
 190         if(buffer==0) {
 191             result.truncate(0);
 192             return result;
 193         }
 194         errorCode=U_ZERO_ERROR;
 195         length=uloc_getDisplayVariant(fullName, displayLocale.fullName,
 196                                       buffer, result.getCapacity(),
 197                                       &errorCode);
 198         result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 199     }
 200
 201     return result;
 202 }
 203
 204 UnicodeString&
 205 Locale::getDisplayName( UnicodeString& name ) const
 206 {
 207     return this->getDisplayName(getDefault(), name);
 208 }
 209
 210 UnicodeString&
 211 Locale::getDisplayName(const Locale &displayLocale,
 212                        UnicodeString &result) const {
 213     UChar *buffer;
 214     UErrorCode errorCode=U_ZERO_ERROR;
 215     int32_t length;
 216
 217     buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY);
 218     if(buffer==0) {
 219         result.truncate(0);
 220         return result;
 221     }
 222
 223     length=uloc_getDisplayName(fullName, displayLocale.fullName,
 224                                buffer, result.getCapacity(),
 225                                &errorCode);
 226     result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 227
 228     if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
 229         buffer=result.getBuffer(length);
 230         if(buffer==0) {
 231             result.truncate(0);
 232             return result;
 233         }
 234         errorCode=U_ZERO_ERROR;
 235         length=uloc_getDisplayName(fullName, displayLocale.fullName,
 236                                    buffer, result.getCapacity(),
 237                                    &errorCode);
 238         result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0);
 239     }
 240
 241     return result;
 242 }
 243
 244 #if ! UCONFIG_NO_BREAK_ITERATION
 245
 246 // -------------------------------------
 247 // Gets the objectLocale display name in the default locale language.
 248 UnicodeString& U_EXPORT2
 249 BreakIterator::getDisplayName(const Locale& objectLocale,
 250                              UnicodeString& name)
 251 {
 252     return objectLocale.getDisplayName(name);
 253 }
 254
 255 // -------------------------------------
 256 // Gets the objectLocale display name in the displayLocale language.
 257 UnicodeString& U_EXPORT2
 258 BreakIterator::getDisplayName(const Locale& objectLocale,
 259                              const Locale& displayLocale,
 260                              UnicodeString& name)
 261 {
 262     return objectLocale.getDisplayName(displayLocale, name);
 263 }
 264
 265 #endif
 266
 267
 268 U_NAMESPACE_END
 269
 270 // C API ------------------------------------------------------------------- ***
 271
 272 U_NAMESPACE_USE
 273
 274 /* ### Constants **************************************************/
 275
 276 /* These strings describe the resources we attempt to load from
 277  the locale ResourceBundle data file.*/
 278 static const char _kLanguages[]       = "Languages";
 279 static const char _kScripts[]         = "Scripts";
 280 static const char _kCountries[]       = "Countries";
 281 static const char _kVariants[]        = "Variants";
 282 static const char _kKeys[]            = "Keys";
 283 static const char _kTypes[]           = "Types";
 284 static const char _kRootName[]        = "root";
 285 static const char _kCurrency[]        = "currency";
 286 static const char _kCurrencies[]      = "Currencies";
 287 static const char _kLocaleDisplayPattern[] = "localeDisplayPattern";
 288 static const char _kPattern[]         = "pattern";
 289 static const char _kSeparator[]       = "separator";
 290
 291 /* ### Display name **************************************************/
 292
 293 static int32_t
 294 _getStringOrCopyKey(const char *path, const char *locale,
 295                     const char *tableKey,
 296                     const char* subTableKey,
 297                     const char *itemKey,
 298                     const char *substitute,
 299                     UChar *dest, int32_t destCapacity,
 300                     UErrorCode *pErrorCode) {
 301     const UChar *s = NULL;
 302     int32_t length = 0;
 303
 304     if(itemKey==NULL) {
 305         /* top-level item: normal resource bundle access */
 306         UResourceBundle *rb;
 307
 308         rb=ures_open(path, locale, pErrorCode);
 309
 310         if(U_SUCCESS(*pErrorCode)) {
 311             s=ures_getStringByKey(rb, tableKey, &length, pErrorCode);
 312             /* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */
 313             ures_close(rb);
 314         }
 315     } else {
 316         /* Language code should not be a number. If it is, set the error code. */
 317         if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) {
 318             *pErrorCode = U_MISSING_RESOURCE_ERROR;
 319         } else {
 320             /* second-level item, use special fallback */
 321             s=uloc_getTableStringWithFallback(path, locale,
 322                                                tableKey,
 323                                                subTableKey,
 324                                                itemKey,
 325                                                &length,
 326                                                pErrorCode);
 327         }
 328     }
 329
 330     if(U_SUCCESS(*pErrorCode)) {
 331         int32_t copyLength=uprv_min(length, destCapacity);
 332         if(copyLength>0 && s != NULL) {
 333             u_memcpy(dest, s, copyLength);
 334         }
 335     } else {
 336         /* no string from a resource bundle: convert the substitute */
 337         length=(int32_t)uprv_strlen(substitute);
 338         u_charsToUChars(substitute, dest, uprv_min(length, destCapacity));
 339         *pErrorCode=U_USING_DEFAULT_WARNING;
 340     }
 341
 342     return u_terminateUChars(dest, destCapacity, length, pErrorCode);
 343 }
 344
 345 typedef  int32_t U_CALLCONV UDisplayNameGetter(const char *, char *, int32_t, UErrorCode *);
 346
 347 static int32_t
 348 _getDisplayNameForComponent(const char *locale,
 349                             const char *displayLocale,
 350                             UChar *dest, int32_t destCapacity,
 351                             UDisplayNameGetter *getter,
 352                             const char *tag,
 353                             UErrorCode *pErrorCode) {
 354     char localeBuffer[ULOC_FULLNAME_CAPACITY*4];
 355     int32_t length;
 356     UErrorCode localStatus;
 357     const char* root = NULL;
 358
 359     /* argument checking */
 360     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 361         return 0;
 362     }
 363
 364     if(destCapacity<0 || (destCapacity>0 && dest==NULL)) {
 365         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 366         return 0;
 367     }
 368
 369     localStatus = U_ZERO_ERROR;
 370     length=(*getter)(locale, localeBuffer, sizeof(localeBuffer), &localStatus);
 371     if(U_FAILURE(localStatus) || localStatus==U_STRING_NOT_TERMINATED_WARNING) {
 372         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 373         return 0;
 374     }
 375     if(length==0) {
 376         return u_terminateUChars(dest, destCapacity, 0, pErrorCode);
 377     }
 378
 379     root = tag == _kCountries ? U_ICUDATA_REGION : U_ICUDATA_LANG;
 380
 381     return _getStringOrCopyKey(root, displayLocale,
 382                                tag, NULL, localeBuffer,
 383                                localeBuffer,
 384                                dest, destCapacity,
 385                                pErrorCode);
 386 }
 387
 388 U_CAPI int32_t U_EXPORT2
 389 uloc_getDisplayLanguage(const char *locale,
 390                         const char *displayLocale,
 391                         UChar *dest, int32_t destCapacity,
 392                         UErrorCode *pErrorCode) {
 393     return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
 394                 uloc_getLanguage, _kLanguages, pErrorCode);
 395 }
 396
 397 U_CAPI int32_t U_EXPORT2
 398 uloc_getDisplayScript(const char* locale,
 399                       const char* displayLocale,
 400                       UChar *dest, int32_t destCapacity,
 401                       UErrorCode *pErrorCode)
 402 {
 403     return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
 404                 uloc_getScript, _kScripts, pErrorCode);
 405 }
 406
 407 U_CAPI int32_t U_EXPORT2
 408 uloc_getDisplayCountry(const char *locale,
 409                        const char *displayLocale,
 410                        UChar *dest, int32_t destCapacity,
 411                        UErrorCode *pErrorCode) {
 412     return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
 413                 uloc_getCountry, _kCountries, pErrorCode);
 414 }
 415
 416 /*
 417  * TODO separate variant1_variant2_variant3...
 418  * by getting each tag's display string and concatenating them with ", "
 419  * in between - similar to uloc_getDisplayName()
 420  */
 421 U_CAPI int32_t U_EXPORT2
 422 uloc_getDisplayVariant(const char *locale,
 423                        const char *displayLocale,
 424                        UChar *dest, int32_t destCapacity,
 425                        UErrorCode *pErrorCode) {
 426     return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
 427                 uloc_getVariant, _kVariants, pErrorCode);
 428 }
 429
 430 U_CAPI int32_t U_EXPORT2
 431 uloc_getDisplayName(const char *locale,
 432                     const char *displayLocale,
 433                     UChar *dest, int32_t destCapacity,
 434                     UErrorCode *pErrorCode)
 435 {
 436     int32_t length, length2, length3 = 0;
 437     UBool hasLanguage, hasScript, hasCountry, hasVariant, hasKeywords;
 438     UEnumeration* keywordEnum = NULL;
 439     int32_t keywordCount = 0;
 440     const char *keyword = NULL;
 441     int32_t keywordLen = 0;
 442     char keywordValue[256];
 443     int32_t keywordValueLen = 0;
 444
 445     int32_t locSepLen = 0;
 446     int32_t locPatLen = 0;
 447     int32_t p0Len = 0;
 448     int32_t defaultPatternLen = 9;
 449     const UChar *dispLocSeparator;
 450     const UChar *dispLocPattern;
 451     static const UChar defaultSeparator[3] = { 0x002c, 0x0020 , 0x0000 }; /* comma + space */
 452     static const UChar defaultPattern[10] = { 0x007b, 0x0030, 0x007d, 0x0020, 0x0028, 0x007b, 0x0031, 0x007d, 0x0029, 0x0000 }; /* {0} ({1}) */
 453     static const UChar pat0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */
 454     static const UChar pat1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */
 455
 456     UResourceBundle *bundle = NULL;
 457     UResourceBundle *locdsppat = NULL;
 458
 459     UErrorCode status = U_ZERO_ERROR;
 460
 461     /* argument checking */
 462     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 463         return 0;
 464     }
 465
 466     if(destCapacity<0 || (destCapacity>0 && dest==NULL)) {
 467         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 468         return 0;
 469     }
 470
 471     bundle    = ures_open(U_ICUDATA_LANG, displayLocale, &status);
 472
 473     locdsppat = ures_getByKeyWithFallback(bundle, _kLocaleDisplayPattern, NULL, &status);
 474     dispLocSeparator = ures_getStringByKeyWithFallback(locdsppat, _kSeparator, &locSepLen, &status);
 475     dispLocPattern = ures_getStringByKeyWithFallback(locdsppat, _kPattern, &locPatLen, &status);
 476
 477     /*close the bundles */
 478     ures_close(locdsppat);
 479     ures_close(bundle);
 480
 481     /* If we couldn't find any data, then use the defaults */
 482     if ( locSepLen == 0) {
 483        dispLocSeparator = defaultSeparator;
 484        locSepLen = 2;
 485     }
 486
 487     if ( locPatLen == 0) {
 488        dispLocPattern = defaultPattern;
 489        locPatLen = 9;
 490     }
 491
 492     /*
 493      * if there is a language, then write "language (country, variant)"
 494      * otherwise write "country, variant"
 495      */
 496
 497     /* write the language */
 498     length=uloc_getDisplayLanguage(locale, displayLocale,
 499                                    dest, destCapacity,
 500                                    pErrorCode);
 501     hasLanguage= length>0;
 502
 503     if(hasLanguage) {
 504         p0Len = length;
 505
 506         /* append " (" */
 507         if(length<destCapacity) {
 508             dest[length]=0x20;
 509         }
 510         ++length;
 511         if(length<destCapacity) {
 512             dest[length]=0x28;
 513         }
 514         ++length;
 515     }
 516
 517     if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 518         /* keep preflighting */
 519         *pErrorCode=U_ZERO_ERROR;
 520     }
 521
 522     /* append the script */
 523     if(length<destCapacity) {
 524         length2=uloc_getDisplayScript(locale, displayLocale,
 525                                        dest+length, destCapacity-length,
 526                                        pErrorCode);
 527     } else {
 528         length2=uloc_getDisplayScript(locale, displayLocale,
 529                                        NULL, 0,
 530                                        pErrorCode);
 531     }
 532     hasScript= length2>0;
 533     length+=length2;
 534
 535     if(hasScript) {
 536         /* append separator */
 537         if(length+locSepLen<=destCapacity) {
 538             u_memcpy(dest+length,dispLocSeparator,locSepLen);
 539         }
 540         length+=locSepLen;
 541     }
 542
 543     if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 544         /* keep preflighting */
 545         *pErrorCode=U_ZERO_ERROR;
 546     }
 547
 548     /* append the country */
 549     if(length<destCapacity) {
 550         length2=uloc_getDisplayCountry(locale, displayLocale,
 551                                        dest+length, destCapacity-length,
 552                                        pErrorCode);
 553     } else {
 554         length2=uloc_getDisplayCountry(locale, displayLocale,
 555                                        NULL, 0,
 556                                        pErrorCode);
 557     }
 558     hasCountry= length2>0;
 559     length+=length2;
 560
 561     if(hasCountry) {
 562         /* append separator */
 563         if(length+locSepLen<=destCapacity) {
 564             u_memcpy(dest+length,dispLocSeparator,locSepLen);
 565         }
 566         length+=locSepLen;
 567     }
 568
 569     if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 570         /* keep preflighting */
 571         *pErrorCode=U_ZERO_ERROR;
 572     }
 573
 574     /* append the variant */
 575     if(length<destCapacity) {
 576         length2=uloc_getDisplayVariant(locale, displayLocale,
 577                                        dest+length, destCapacity-length,
 578                                        pErrorCode);
 579     } else {
 580         length2=uloc_getDisplayVariant(locale, displayLocale,
 581                                        NULL, 0,
 582                                        pErrorCode);
 583     }
 584     hasVariant= length2>0;
 585     length+=length2;
 586
 587     if(hasVariant) {
 588         /* append separator */
 589         if(length+locSepLen<=destCapacity) {
 590             u_memcpy(dest+length,dispLocSeparator,locSepLen);
 591         }
 592         length+=locSepLen;
 593     }
 594
 595     keywordEnum = uloc_openKeywords(locale, pErrorCode);
 596
 597     for(keywordCount = uenum_count(keywordEnum, pErrorCode); keywordCount > 0 ; keywordCount--){
 598           if(U_FAILURE(*pErrorCode)){
 599               break;
 600           }
 601           /* the uenum_next returns NUL terminated string */
 602           keyword = uenum_next(keywordEnum, &keywordLen, pErrorCode);
 603           if(length + length3 < destCapacity) {
 604             length3 += uloc_getDisplayKeyword(keyword, displayLocale, dest+length+length3, destCapacity-length-length3, pErrorCode);
 605           } else {
 606             length3 += uloc_getDisplayKeyword(keyword, displayLocale, NULL, 0, pErrorCode);
 607           }
 608           if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 609               /* keep preflighting */
 610               *pErrorCode=U_ZERO_ERROR;
 611           }
 612           keywordValueLen = uloc_getKeywordValue(locale, keyword, keywordValue, 256, pErrorCode);
 613           if(keywordValueLen) {
 614             if(length + length3 < destCapacity) {
 615               dest[length + length3] = 0x3D;
 616             }
 617             length3++;
 618             if(length + length3 < destCapacity) {
 619               length3 += uloc_getDisplayKeywordValue(locale, keyword, displayLocale, dest+length+length3, destCapacity-length-length3, pErrorCode);
 620             } else {
 621               length3 += uloc_getDisplayKeywordValue(locale, keyword, displayLocale, NULL, 0, pErrorCode);
 622             }
 623             if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 624                 /* keep preflighting */
 625                 *pErrorCode=U_ZERO_ERROR;
 626             }
 627           }
 628           if(keywordCount > 1) {
 629               if(length + length3 + locSepLen <= destCapacity && keywordCount) {
 630                   u_memcpy(dest+length+length3,dispLocSeparator,locSepLen);
 631                   length3+=locSepLen;
 632               }
 633           }
 634     }
 635     uenum_close(keywordEnum);
 636
 637     hasKeywords = length3 > 0;
 638     length += length3;
 639
 640
 641     if ((hasScript && !hasCountry)
 642         || ((hasScript || hasCountry) && !hasVariant && !hasKeywords)
 643         || ((hasScript || hasCountry || hasVariant) && !hasKeywords)) {
 644         /* Remove separator  */
 645         length -= locSepLen;
 646     } else if (hasLanguage && !hasScript && !hasCountry && !hasVariant && !hasKeywords) {
 647         /* Remove " (" */
 648         length-=2;
 649     }
 650
 651     if (hasLanguage && (hasScript || hasCountry || hasVariant || hasKeywords)) {
 652         /* append ")" */
 653         if(length<destCapacity) {
 654             dest[length]=0x29;
 655         }
 656         ++length;
 657
 658         /* If the localized display pattern is something other than the default pattern of "{0} ({1})", then
 659          * then we need to do the formatting here.  It would be easier to use a messageFormat to do this, but we
 660          * can't since we don't have the APIs in the i18n library available to us at this point.
 661          */
 662         if (locPatLen != defaultPatternLen || u_strcmp(dispLocPattern,defaultPattern)) { /* Something other than the default pattern */
 663            UChar *p0 = u_strstr(dispLocPattern,pat0);
 664            UChar *p1 = u_strstr(dispLocPattern,pat1);
 665            u_terminateUChars(dest, destCapacity, length, pErrorCode);
 666
 667            if ( p0 != NULL && p1 != NULL ) { /* The pattern is well formed */
 668               if ( dest ) {
 669                   int32_t destLen = 0;
 670                   UChar *result = (UChar *)uprv_malloc((length+1)*sizeof(UChar));
 671                   UChar *upos = (UChar *)dispLocPattern;
 672                   u_strcpy(result,dest);
 673                   dest[0] = 0;
 674                   while ( *upos ) {
 675                      if ( upos == p0 ) { /* Handle {0} substitution */
 676                          u_strncat(dest,result,p0Len);
 677                          destLen += p0Len;
 678                          dest[destLen] = 0; /* Null terminate */
 679                          upos += 3;
 680                      } else if ( upos == p1 ) { /* Handle {1} substitution */
 681                          UChar *p1Start = &result[p0Len+2];
 682                          u_strncat(dest,p1Start,length-p0Len-3);
 683                          destLen += (length-p0Len-3);
 684                          dest[destLen] = 0; /* Null terminate */
 685                          upos += 3;
 686                      } else { /* Something from the pattern not {0} or {1} */
 687                          u_strncat(dest,upos,1);
 688                          upos++;
 689                          destLen++;
 690                          dest[destLen] = 0; /* Null terminate */
 691                      }
 692                   }
 693                   length = destLen;
 694                   uprv_free(result);
 695               }
 696            }
 697         }
 698     }
 699     if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 700         /* keep preflighting */
 701         *pErrorCode=U_ZERO_ERROR;
 702     }
 703
 704     return u_terminateUChars(dest, destCapacity, length, pErrorCode);
 705 }
 706
 707 U_CAPI int32_t U_EXPORT2
 708 uloc_getDisplayKeyword(const char* keyword,
 709                        const char* displayLocale,
 710                        UChar* dest,
 711                        int32_t destCapacity,
 712                        UErrorCode* status){
 713
 714     /* argument checking */
 715     if(status==NULL || U_FAILURE(*status)) {
 716         return 0;
 717     }
 718
 719     if(destCapacity<0 || (destCapacity>0 && dest==NULL)) {
 720         *status=U_ILLEGAL_ARGUMENT_ERROR;
 721         return 0;
 722     }
 723
 724
 725     /* pass itemKey=NULL to look for a top-level item */
 726     return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale,
 727                                _kKeys, NULL,
 728                                keyword,
 729                                keyword,
 730                                dest, destCapacity,
 731                                status);
 732
 733 }
 734
 735
 736 #define UCURRENCY_DISPLAY_NAME_INDEX 1
 737
 738 U_CAPI int32_t U_EXPORT2
 739 uloc_getDisplayKeywordValue(   const char* locale,
 740                                const char* keyword,
 741                                const char* displayLocale,
 742                                UChar* dest,
 743                                int32_t destCapacity,
 744                                UErrorCode* status){
 745
 746
 747     char keywordValue[ULOC_FULLNAME_CAPACITY*4];
 748     int32_t capacity = ULOC_FULLNAME_CAPACITY*4;
 749     int32_t keywordValueLen =0;
 750
 751     /* argument checking */
 752     if(status==NULL || U_FAILURE(*status)) {
 753         return 0;
 754     }
 755
 756     if(destCapacity<0 || (destCapacity>0 && dest==NULL)) {
 757         *status=U_ILLEGAL_ARGUMENT_ERROR;
 758         return 0;
 759     }
 760
 761     /* get the keyword value */
 762     keywordValue[0]=0;
 763     keywordValueLen = uloc_getKeywordValue(locale, keyword, keywordValue, capacity, status);
 764
 765     /*
 766      * if the keyword is equal to currency .. then to get the display name
 767      * we need to do the fallback ourselves
 768      */
 769     if(uprv_stricmp(keyword, _kCurrency)==0){
 770
 771         int32_t dispNameLen = 0;
 772         const UChar *dispName = NULL;
 773
 774         UResourceBundle *bundle     = ures_open(U_ICUDATA_CURR, displayLocale, status);
 775         UResourceBundle *currencies = ures_getByKey(bundle, _kCurrencies, NULL, status);
 776         UResourceBundle *currency   = ures_getByKeyWithFallback(currencies, keywordValue, NULL, status);
 777
 778         dispName = ures_getStringByIndex(currency, UCURRENCY_DISPLAY_NAME_INDEX, &dispNameLen, status);
 779
 780         /*close the bundles */
 781         ures_close(currency);
 782         ures_close(currencies);
 783         ures_close(bundle);
 784
 785         if(U_FAILURE(*status)){
 786             if(*status == U_MISSING_RESOURCE_ERROR){
 787                 /* we just want to write the value over if nothing is available */
 788                 *status = U_USING_DEFAULT_WARNING;
 789             }else{
 790                 return 0;
 791             }
 792         }
 793
 794         /* now copy the dispName over if not NULL */
 795         if(dispName != NULL){
 796             if(dispNameLen <= destCapacity){
 797                 uprv_memcpy(dest, dispName, dispNameLen * U_SIZEOF_UCHAR);
 798                 return u_terminateUChars(dest, destCapacity, dispNameLen, status);
 799             }else{
 800                 *status = U_BUFFER_OVERFLOW_ERROR;
 801                 return dispNameLen;
 802             }
 803         }else{
 804             /* we have not found the display name for the value .. just copy over */
 805             if(keywordValueLen <= destCapacity){
 806                 u_charsToUChars(keywordValue, dest, keywordValueLen);
 807                 return u_terminateUChars(dest, destCapacity, keywordValueLen, status);
 808             }else{
 809                  *status = U_BUFFER_OVERFLOW_ERROR;
 810                 return keywordValueLen;
 811             }
 812         }
 813
 814
 815     }else{
 816
 817         return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale,
 818                                    _kTypes, keyword,
 819                                    keywordValue,
 820                                    keywordValue,
 821                                    dest, destCapacity,
 822                                    status);
 823     }
 824 }