1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************* 5 * 6 * Copyright (C) 1997-2016, International Business Machines 7 * Corporation and others. All Rights Reserved. 8 * 9 ******************************************************************************* 10 * file name: locdispnames.cpp 11 * encoding: UTF-8 12 * tab size: 8 (not used) 13 * indentation:4 14 * 15 * created on: 2010feb25 16 * created by: Markus W. Scherer 17 * 18 * Code for locale display names, separated out from other .cpp files 19 * that then do not depend on resource bundle code and display name data. 20 */ 21 22 #include "unicode/utypes.h" 23 #include "unicode/brkiter.h" 24 #include "unicode/locid.h" 25 #include "unicode/uloc.h" 26 #include "unicode/ures.h" 27 #include "unicode/ustring.h" 28 #include "cmemory.h" 29 #include "cstring.h" 30 #include "putilimp.h" 31 #include "ulocimp.h" 32 #include "uresimp.h" 33 #include "ureslocs.h" 34 #include "ustr_imp.h" 35 36 // C++ API ----------------------------------------------------------------- *** 37 38 U_NAMESPACE_BEGIN 39 40 UnicodeString& 41 Locale::getDisplayLanguage(UnicodeString& dispLang) const 42 { 43 return this->getDisplayLanguage(getDefault(), dispLang); 44 } 45 46 /*We cannot make any assumptions on the size of the output display strings 47 * Yet, since we are calling through to a C API, we need to set limits on 48 * buffer size. For all the following getDisplay functions we first attempt 49 * to fill up a stack allocated buffer. If it is to small we heap allocated 50 * the exact buffer we need copy it to the UnicodeString and delete it*/ 51 52 UnicodeString& 53 Locale::getDisplayLanguage(const Locale &displayLocale, 54 UnicodeString &result) const { 55 UChar *buffer; 56 UErrorCode errorCode=U_ZERO_ERROR; 57 int32_t length; 58 59 buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); 60 if(buffer==0) { 61 result.truncate(0); 62 return result; 63 } 64 65 length=uloc_getDisplayLanguage(fullName, displayLocale.fullName, 66 buffer, result.getCapacity(), 67 &errorCode); 68 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 69 70 if(errorCode==U_BUFFER_OVERFLOW_ERROR) { 71 buffer=result.getBuffer(length); 72 if(buffer==0) { 73 result.truncate(0); 74 return result; 75 } 76 errorCode=U_ZERO_ERROR; 77 length=uloc_getDisplayLanguage(fullName, displayLocale.fullName, 78 buffer, result.getCapacity(), 79 &errorCode); 80 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 81 } 82 83 return result; 84 } 85 86 UnicodeString& 87 Locale::getDisplayScript(UnicodeString& dispScript) const 88 { 89 return this->getDisplayScript(getDefault(), dispScript); 90 } 91 92 UnicodeString& 93 Locale::getDisplayScript(const Locale &displayLocale, 94 UnicodeString &result) const { 95 UChar *buffer; 96 UErrorCode errorCode=U_ZERO_ERROR; 97 int32_t length; 98 99 buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); 100 if(buffer==0) { 101 result.truncate(0); 102 return result; 103 } 104 105 length=uloc_getDisplayScript(fullName, displayLocale.fullName, 106 buffer, result.getCapacity(), 107 &errorCode); 108 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 109 110 if(errorCode==U_BUFFER_OVERFLOW_ERROR) { 111 buffer=result.getBuffer(length); 112 if(buffer==0) { 113 result.truncate(0); 114 return result; 115 } 116 errorCode=U_ZERO_ERROR; 117 length=uloc_getDisplayScript(fullName, displayLocale.fullName, 118 buffer, result.getCapacity(), 119 &errorCode); 120 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 121 } 122 123 return result; 124 } 125 126 UnicodeString& 127 Locale::getDisplayCountry(UnicodeString& dispCntry) const 128 { 129 return this->getDisplayCountry(getDefault(), dispCntry); 130 } 131 132 UnicodeString& 133 Locale::getDisplayCountry(const Locale &displayLocale, 134 UnicodeString &result) const { 135 UChar *buffer; 136 UErrorCode errorCode=U_ZERO_ERROR; 137 int32_t length; 138 139 buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); 140 if(buffer==0) { 141 result.truncate(0); 142 return result; 143 } 144 145 length=uloc_getDisplayCountry(fullName, displayLocale.fullName, 146 buffer, result.getCapacity(), 147 &errorCode); 148 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 149 150 if(errorCode==U_BUFFER_OVERFLOW_ERROR) { 151 buffer=result.getBuffer(length); 152 if(buffer==0) { 153 result.truncate(0); 154 return result; 155 } 156 errorCode=U_ZERO_ERROR; 157 length=uloc_getDisplayCountry(fullName, displayLocale.fullName, 158 buffer, result.getCapacity(), 159 &errorCode); 160 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 161 } 162 163 return result; 164 } 165 166 UnicodeString& 167 Locale::getDisplayVariant(UnicodeString& dispVar) const 168 { 169 return this->getDisplayVariant(getDefault(), dispVar); 170 } 171 172 UnicodeString& 173 Locale::getDisplayVariant(const Locale &displayLocale, 174 UnicodeString &result) const { 175 UChar *buffer; 176 UErrorCode errorCode=U_ZERO_ERROR; 177 int32_t length; 178 179 buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); 180 if(buffer==0) { 181 result.truncate(0); 182 return result; 183 } 184 185 length=uloc_getDisplayVariant(fullName, displayLocale.fullName, 186 buffer, result.getCapacity(), 187 &errorCode); 188 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 189 190 if(errorCode==U_BUFFER_OVERFLOW_ERROR) { 191 buffer=result.getBuffer(length); 192 if(buffer==0) { 193 result.truncate(0); 194 return result; 195 } 196 errorCode=U_ZERO_ERROR; 197 length=uloc_getDisplayVariant(fullName, displayLocale.fullName, 198 buffer, result.getCapacity(), 199 &errorCode); 200 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 201 } 202 203 return result; 204 } 205 206 UnicodeString& 207 Locale::getDisplayName( UnicodeString& name ) const 208 { 209 return this->getDisplayName(getDefault(), name); 210 } 211 212 UnicodeString& 213 Locale::getDisplayName(const Locale &displayLocale, 214 UnicodeString &result) const { 215 UChar *buffer; 216 UErrorCode errorCode=U_ZERO_ERROR; 217 int32_t length; 218 219 buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); 220 if(buffer==0) { 221 result.truncate(0); 222 return result; 223 } 224 225 length=uloc_getDisplayName(fullName, displayLocale.fullName, 226 buffer, result.getCapacity(), 227 &errorCode); 228 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 229 230 if(errorCode==U_BUFFER_OVERFLOW_ERROR) { 231 buffer=result.getBuffer(length); 232 if(buffer==0) { 233 result.truncate(0); 234 return result; 235 } 236 errorCode=U_ZERO_ERROR; 237 length=uloc_getDisplayName(fullName, displayLocale.fullName, 238 buffer, result.getCapacity(), 239 &errorCode); 240 result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); 241 } 242 243 return result; 244 } 245 246 #if ! UCONFIG_NO_BREAK_ITERATION 247 248 // ------------------------------------- 249 // Gets the objectLocale display name in the default locale language. 250 UnicodeString& U_EXPORT2 251 BreakIterator::getDisplayName(const Locale& objectLocale, 252 UnicodeString& name) 253 { 254 return objectLocale.getDisplayName(name); 255 } 256 257 // ------------------------------------- 258 // Gets the objectLocale display name in the displayLocale language. 259 UnicodeString& U_EXPORT2 260 BreakIterator::getDisplayName(const Locale& objectLocale, 261 const Locale& displayLocale, 262 UnicodeString& name) 263 { 264 return objectLocale.getDisplayName(displayLocale, name); 265 } 266 267 #endif 268 269 270 U_NAMESPACE_END 271 272 // C API ------------------------------------------------------------------- *** 273 274 U_NAMESPACE_USE 275 276 /* ### Constants **************************************************/ 277 278 /* These strings describe the resources we attempt to load from 279 the locale ResourceBundle data file.*/ 280 static const char _kLanguages[] = "Languages"; 281 static const char _kScripts[] = "Scripts"; 282 static const char _kScriptsStandAlone[] = "Scripts%stand-alone"; 283 static const char _kCountries[] = "Countries"; 284 static const char _kVariants[] = "Variants"; 285 static const char _kKeys[] = "Keys"; 286 static const char _kTypes[] = "Types"; 287 //static const char _kRootName[] = "root"; 288 static const char _kCurrency[] = "currency"; 289 static const char _kCurrencies[] = "Currencies"; 290 static const char _kLocaleDisplayPattern[] = "localeDisplayPattern"; 291 static const char _kPattern[] = "pattern"; 292 static const char _kSeparator[] = "separator"; 293 294 /* ### Display name **************************************************/ 295 296 static int32_t 297 _getStringOrCopyKey(const char *path, const char *locale, 298 const char *tableKey, 299 const char* subTableKey, 300 const char *itemKey, 301 const char *substitute, 302 UChar *dest, int32_t destCapacity, 303 UErrorCode *pErrorCode) { 304 const UChar *s = NULL; 305 int32_t length = 0; 306 307 if(itemKey==NULL) { 308 /* top-level item: normal resource bundle access */ 309 UResourceBundle *rb; 310 311 rb=ures_open(path, locale, pErrorCode); 312 313 if(U_SUCCESS(*pErrorCode)) { 314 s=ures_getStringByKey(rb, tableKey, &length, pErrorCode); 315 /* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */ 316 ures_close(rb); 317 } 318 } else { 319 /* Language code should not be a number. If it is, set the error code. */ 320 if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) { 321 *pErrorCode = U_MISSING_RESOURCE_ERROR; 322 } else { 323 /* second-level item, use special fallback */ 324 s=uloc_getTableStringWithFallback(path, locale, 325 tableKey, 326 subTableKey, 327 itemKey, 328 &length, 329 pErrorCode); 330 } 331 } 332 333 if(U_SUCCESS(*pErrorCode)) { 334 int32_t copyLength=uprv_min(length, destCapacity); 335 if(copyLength>0 && s != NULL) { 336 u_memcpy(dest, s, copyLength); 337 } 338 } else { 339 /* no string from a resource bundle: convert the substitute */ 340 length=(int32_t)uprv_strlen(substitute); 341 u_charsToUChars(substitute, dest, uprv_min(length, destCapacity)); 342 *pErrorCode=U_USING_DEFAULT_WARNING; 343 } 344 345 return u_terminateUChars(dest, destCapacity, length, pErrorCode); 346 } 347 348 typedef int32_t U_CALLCONV UDisplayNameGetter(const char *, char *, int32_t, UErrorCode *); 349 350 static int32_t 351 _getDisplayNameForComponent(const char *locale, 352 const char *displayLocale, 353 UChar *dest, int32_t destCapacity, 354 UDisplayNameGetter *getter, 355 const char *tag, 356 UErrorCode *pErrorCode) { 357 char localeBuffer[ULOC_FULLNAME_CAPACITY*4]; 358 int32_t length; 359 UErrorCode localStatus; 360 const char* root = NULL; 361 362 /* argument checking */ 363 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 364 return 0; 365 } 366 367 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 368 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 369 return 0; 370 } 371 372 localStatus = U_ZERO_ERROR; 373 length=(*getter)(locale, localeBuffer, sizeof(localeBuffer), &localStatus); 374 if(U_FAILURE(localStatus) || localStatus==U_STRING_NOT_TERMINATED_WARNING) { 375 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 376 return 0; 377 } 378 if(length==0) { 379 return u_terminateUChars(dest, destCapacity, 0, pErrorCode); 380 } 381 382 root = tag == _kCountries ? U_ICUDATA_REGION : U_ICUDATA_LANG; 383 384 return _getStringOrCopyKey(root, displayLocale, 385 tag, NULL, localeBuffer, 386 localeBuffer, 387 dest, destCapacity, 388 pErrorCode); 389 } 390 391 U_CAPI int32_t U_EXPORT2 392 uloc_getDisplayLanguage(const char *locale, 393 const char *displayLocale, 394 UChar *dest, int32_t destCapacity, 395 UErrorCode *pErrorCode) { 396 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 397 uloc_getLanguage, _kLanguages, pErrorCode); 398 } 399 400 U_CAPI int32_t U_EXPORT2 401 uloc_getDisplayScript(const char* locale, 402 const char* displayLocale, 403 UChar *dest, int32_t destCapacity, 404 UErrorCode *pErrorCode) 405 { 406 UErrorCode err = U_ZERO_ERROR; 407 int32_t res = _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 408 uloc_getScript, _kScriptsStandAlone, &err); 409 410 if ( err == U_USING_DEFAULT_WARNING ) { 411 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 412 uloc_getScript, _kScripts, pErrorCode); 413 } else { 414 *pErrorCode = err; 415 return res; 416 } 417 } 418 419 U_INTERNAL int32_t U_EXPORT2 420 uloc_getDisplayScriptInContext(const char* locale, 421 const char* displayLocale, 422 UChar *dest, int32_t destCapacity, 423 UErrorCode *pErrorCode) 424 { 425 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 426 uloc_getScript, _kScripts, pErrorCode); 427 } 428 429 U_CAPI int32_t U_EXPORT2 430 uloc_getDisplayCountry(const char *locale, 431 const char *displayLocale, 432 UChar *dest, int32_t destCapacity, 433 UErrorCode *pErrorCode) { 434 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 435 uloc_getCountry, _kCountries, pErrorCode); 436 } 437 438 /* 439 * TODO separate variant1_variant2_variant3... 440 * by getting each tag's display string and concatenating them with ", " 441 * in between - similar to uloc_getDisplayName() 442 */ 443 U_CAPI int32_t U_EXPORT2 444 uloc_getDisplayVariant(const char *locale, 445 const char *displayLocale, 446 UChar *dest, int32_t destCapacity, 447 UErrorCode *pErrorCode) { 448 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 449 uloc_getVariant, _kVariants, pErrorCode); 450 } 451 452 /* Instead of having a separate pass for 'special' patterns, reintegrate the two 453 * so we don't get bitten by preflight bugs again. We can be reasonably efficient 454 * without two separate code paths, this code isn't that performance-critical. 455 * 456 * This code is general enough to deal with patterns that have a prefix or swap the 457 * language and remainder components, since we gave developers enough rope to do such 458 * things if they futz with the pattern data. But since we don't give them a way to 459 * specify a pattern for arbitrary combinations of components, there's not much use in 460 * that. I don't think our data includes such patterns, the only variable I know if is 461 * whether there is a space before the open paren, or not. Oh, and zh uses different 462 * chars than the standard open/close paren (which ja and ko use, btw). 463 */ 464 U_CAPI int32_t U_EXPORT2 465 uloc_getDisplayName(const char *locale, 466 const char *displayLocale, 467 UChar *dest, int32_t destCapacity, 468 UErrorCode *pErrorCode) 469 { 470 static const UChar defaultSeparator[9] = { 0x007b, 0x0030, 0x007d, 0x002c, 0x0020, 0x007b, 0x0031, 0x007d, 0x0000 }; /* "{0}, {1}" */ 471 static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */ 472 static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */ 473 static const int32_t subLen = 3; 474 static const UChar defaultPattern[10] = { 475 0x007b, 0x0030, 0x007d, 0x0020, 0x0028, 0x007b, 0x0031, 0x007d, 0x0029, 0x0000 476 }; /* {0} ({1}) */ 477 static const int32_t defaultPatLen = 9; 478 static const int32_t defaultSub0Pos = 0; 479 static const int32_t defaultSub1Pos = 5; 480 481 int32_t length; /* of formatted result */ 482 483 const UChar *separator; 484 int32_t sepLen = 0; 485 const UChar *pattern; 486 int32_t patLen = 0; 487 int32_t sub0Pos, sub1Pos; 488 489 UChar formatOpenParen = 0x0028; // ( 490 UChar formatReplaceOpenParen = 0x005B; // [ 491 UChar formatCloseParen = 0x0029; // ) 492 UChar formatReplaceCloseParen = 0x005D; // ] 493 494 UBool haveLang = TRUE; /* assume true, set false if we find we don't have 495 a lang component in the locale */ 496 UBool haveRest = TRUE; /* assume true, set false if we find we don't have 497 any other component in the locale */ 498 UBool retry = FALSE; /* set true if we need to retry, see below */ 499 500 int32_t langi = 0; /* index of the language substitution (0 or 1), virtually always 0 */ 501 502 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 503 return 0; 504 } 505 506 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 507 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 508 return 0; 509 } 510 511 { 512 UErrorCode status = U_ZERO_ERROR; 513 UResourceBundle* locbundle=ures_open(U_ICUDATA_LANG, displayLocale, &status); 514 UResourceBundle* dspbundle=ures_getByKeyWithFallback(locbundle, _kLocaleDisplayPattern, 515 NULL, &status); 516 517 separator=ures_getStringByKeyWithFallback(dspbundle, _kSeparator, &sepLen, &status); 518 pattern=ures_getStringByKeyWithFallback(dspbundle, _kPattern, &patLen, &status); 519 520 ures_close(dspbundle); 521 ures_close(locbundle); 522 } 523 524 /* If we couldn't find any data, then use the defaults */ 525 if(sepLen == 0) { 526 separator = defaultSeparator; 527 } 528 /* #10244: Even though separator is now a pattern, it is awkward to handle it as such 529 * here since we are trying to build the display string in place in the dest buffer, 530 * and to handle it as a pattern would entail having separate storage for the 531 * substrings that need to be combined (the first of which may be the result of 532 * previous such combinations). So for now we continue to treat the portion between 533 * {0} and {1} as a string to be appended when joining substrings, ignoring anything 534 * that is before {0} or after {1} (no existing separator pattern has any such thing). 535 * This is similar to how pattern is handled below. 536 */ 537 { 538 UChar *p0=u_strstr(separator, sub0); 539 UChar *p1=u_strstr(separator, sub1); 540 if (p0==NULL || p1==NULL || p1<p0) { 541 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 542 return 0; 543 } 544 separator = (const UChar *)p0 + subLen; 545 sepLen = static_cast<int32_t>(p1 - separator); 546 } 547 548 if(patLen==0 || (patLen==defaultPatLen && !u_strncmp(pattern, defaultPattern, patLen))) { 549 pattern=defaultPattern; 550 patLen=defaultPatLen; 551 sub0Pos=defaultSub0Pos; 552 sub1Pos=defaultSub1Pos; 553 // use default formatOpenParen etc. set above 554 } else { /* non-default pattern */ 555 UChar *p0=u_strstr(pattern, sub0); 556 UChar *p1=u_strstr(pattern, sub1); 557 if (p0==NULL || p1==NULL) { 558 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 559 return 0; 560 } 561 sub0Pos = static_cast<int32_t>(p0-pattern); 562 sub1Pos = static_cast<int32_t>(p1-pattern); 563 if (sub1Pos < sub0Pos) { /* a very odd pattern */ 564 int32_t t=sub0Pos; sub0Pos=sub1Pos; sub1Pos=t; 565 langi=1; 566 } 567 if (u_strchr(pattern, 0xFF08) != NULL) { 568 formatOpenParen = 0xFF08; // fullwidth ( 569 formatReplaceOpenParen = 0xFF3B; // fullwidth [ 570 formatCloseParen = 0xFF09; // fullwidth ) 571 formatReplaceCloseParen = 0xFF3D; // fullwidth ] 572 } 573 } 574 575 /* We loop here because there is one case in which after the first pass we could need to 576 * reextract the data. If there's initial padding before the first element, we put in 577 * the padding and then write that element. If it turns out there's no second element, 578 * we didn't need the padding. If we do need the data (no preflight), and the first element 579 * would have fit but for the padding, we need to reextract. In this case (only) we 580 * adjust the parameters so padding is not added, and repeat. 581 */ 582 do { 583 UChar* p=dest; 584 int32_t patPos=0; /* position in the pattern, used for non-substitution portions */ 585 int32_t langLen=0; /* length of language substitution */ 586 int32_t langPos=0; /* position in output of language substitution */ 587 int32_t restLen=0; /* length of 'everything else' substitution */ 588 int32_t restPos=0; /* position in output of 'everything else' substitution */ 589 UEnumeration* kenum = NULL; /* keyword enumeration */ 590 591 /* prefix of pattern, extremely likely to be empty */ 592 if(sub0Pos) { 593 if(destCapacity >= sub0Pos) { 594 while (patPos < sub0Pos) { 595 *p++ = pattern[patPos++]; 596 } 597 } else { 598 patPos=sub0Pos; 599 } 600 length=sub0Pos; 601 } else { 602 length=0; 603 } 604 605 for(int32_t subi=0,resti=0;subi<2;) { /* iterate through patterns 0 and 1*/ 606 UBool subdone = FALSE; /* set true when ready to move to next substitution */ 607 608 /* prep p and cap for calls to get display components, pin cap to 0 since 609 they complain if cap is negative */ 610 int32_t cap=destCapacity-length; 611 if (cap <= 0) { 612 cap=0; 613 } else { 614 p=dest+length; 615 } 616 617 if (subi == langi) { /* {0}*/ 618 if(haveLang) { 619 langPos=length; 620 langLen=uloc_getDisplayLanguage(locale, displayLocale, p, cap, pErrorCode); 621 length+=langLen; 622 haveLang=langLen>0; 623 } 624 subdone=TRUE; 625 } else { /* {1} */ 626 if(!haveRest) { 627 subdone=TRUE; 628 } else { 629 int32_t len; /* length of component (plus other stuff) we just fetched */ 630 switch(resti++) { 631 case 0: 632 restPos=length; 633 len=uloc_getDisplayScriptInContext(locale, displayLocale, p, cap, pErrorCode); 634 break; 635 case 1: 636 len=uloc_getDisplayCountry(locale, displayLocale, p, cap, pErrorCode); 637 break; 638 case 2: 639 len=uloc_getDisplayVariant(locale, displayLocale, p, cap, pErrorCode); 640 break; 641 case 3: 642 kenum = uloc_openKeywords(locale, pErrorCode); 643 U_FALLTHROUGH; 644 default: { 645 const char* kw=uenum_next(kenum, &len, pErrorCode); 646 if (kw == NULL) { 647 uenum_close(kenum); 648 len=0; /* mark that we didn't add a component */ 649 subdone=TRUE; 650 } else { 651 /* incorporating this behavior into the loop made it even more complex, 652 so just special case it here */ 653 len = uloc_getDisplayKeyword(kw, displayLocale, p, cap, pErrorCode); 654 if(len) { 655 if(len < cap) { 656 p[len]=0x3d; /* '=', assume we'll need it */ 657 } 658 len+=1; 659 660 /* adjust for call to get keyword */ 661 cap-=len; 662 if(cap <= 0) { 663 cap=0; 664 } else { 665 p+=len; 666 } 667 } 668 /* reset for call below */ 669 if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) { 670 *pErrorCode=U_ZERO_ERROR; 671 } 672 int32_t vlen = uloc_getDisplayKeywordValue(locale, kw, displayLocale, 673 p, cap, pErrorCode); 674 if(len) { 675 if(vlen==0) { 676 --len; /* remove unneeded '=' */ 677 } 678 /* restore cap and p to what they were at start */ 679 cap=destCapacity-length; 680 if(cap <= 0) { 681 cap=0; 682 } else { 683 p=dest+length; 684 } 685 } 686 len+=vlen; /* total we added for key + '=' + value */ 687 } 688 } break; 689 } /* end switch */ 690 691 if (len>0) { 692 /* we addeed a component, so add separator and write it if there's room. */ 693 if(len+sepLen<=cap) { 694 const UChar * plimit = p + len; 695 for (; p < plimit; p++) { 696 if (*p == formatOpenParen) { 697 *p = formatReplaceOpenParen; 698 } else if (*p == formatCloseParen) { 699 *p = formatReplaceCloseParen; 700 } 701 } 702 for(int32_t i=0;i<sepLen;++i) { 703 *p++=separator[i]; 704 } 705 } 706 length+=len+sepLen; 707 } else if(subdone) { 708 /* remove separator if we added it */ 709 if (length!=restPos) { 710 length-=sepLen; 711 } 712 restLen=length-restPos; 713 haveRest=restLen>0; 714 } 715 } 716 } 717 718 if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) { 719 *pErrorCode=U_ZERO_ERROR; 720 } 721 722 if(subdone) { 723 if(haveLang && haveRest) { 724 /* append internal portion of pattern, the first time, 725 or last portion of pattern the second time */ 726 int32_t padLen; 727 patPos+=subLen; 728 padLen=(subi==0 ? sub1Pos : patLen)-patPos; 729 if(length+padLen < destCapacity) { 730 p=dest+length; 731 for(int32_t i=0;i<padLen;++i) { 732 *p++=pattern[patPos++]; 733 } 734 } else { 735 patPos+=padLen; 736 } 737 length+=padLen; 738 } else if(subi==0) { 739 /* don't have first component, reset for second component */ 740 sub0Pos=0; 741 length=0; 742 } else if(length>0) { 743 /* true length is the length of just the component we got. */ 744 length=haveLang?langLen:restLen; 745 if(dest && sub0Pos!=0) { 746 if (sub0Pos+length<=destCapacity) { 747 /* first component not at start of result, 748 but we have full component in buffer. */ 749 u_memmove(dest, dest+(haveLang?langPos:restPos), length); 750 } else { 751 /* would have fit, but didn't because of pattern prefix. */ 752 sub0Pos=0; /* stops initial padding (and a second retry, 753 so we won't end up here again) */ 754 retry=TRUE; 755 } 756 } 757 } 758 759 ++subi; /* move on to next substitution */ 760 } 761 } 762 } while(retry); 763 764 return u_terminateUChars(dest, destCapacity, length, pErrorCode); 765 } 766 767 U_CAPI int32_t U_EXPORT2 768 uloc_getDisplayKeyword(const char* keyword, 769 const char* displayLocale, 770 UChar* dest, 771 int32_t destCapacity, 772 UErrorCode* status){ 773 774 /* argument checking */ 775 if(status==NULL || U_FAILURE(*status)) { 776 return 0; 777 } 778 779 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 780 *status=U_ILLEGAL_ARGUMENT_ERROR; 781 return 0; 782 } 783 784 785 /* pass itemKey=NULL to look for a top-level item */ 786 return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale, 787 _kKeys, NULL, 788 keyword, 789 keyword, 790 dest, destCapacity, 791 status); 792 793 } 794 795 796 #define UCURRENCY_DISPLAY_NAME_INDEX 1 797 798 U_CAPI int32_t U_EXPORT2 799 uloc_getDisplayKeywordValue( const char* locale, 800 const char* keyword, 801 const char* displayLocale, 802 UChar* dest, 803 int32_t destCapacity, 804 UErrorCode* status){ 805 806 807 char keywordValue[ULOC_FULLNAME_CAPACITY*4]; 808 int32_t capacity = ULOC_FULLNAME_CAPACITY*4; 809 int32_t keywordValueLen =0; 810 811 /* argument checking */ 812 if(status==NULL || U_FAILURE(*status)) { 813 return 0; 814 } 815 816 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 817 *status=U_ILLEGAL_ARGUMENT_ERROR; 818 return 0; 819 } 820 821 /* get the keyword value */ 822 keywordValue[0]=0; 823 keywordValueLen = uloc_getKeywordValue(locale, keyword, keywordValue, capacity, status); 824 if (*status == U_STRING_NOT_TERMINATED_WARNING) 825 *status = U_BUFFER_OVERFLOW_ERROR; 826 827 /* 828 * if the keyword is equal to currency .. then to get the display name 829 * we need to do the fallback ourselves 830 */ 831 if(uprv_stricmp(keyword, _kCurrency)==0){ 832 833 int32_t dispNameLen = 0; 834 const UChar *dispName = NULL; 835 836 UResourceBundle *bundle = ures_open(U_ICUDATA_CURR, displayLocale, status); 837 UResourceBundle *currencies = ures_getByKey(bundle, _kCurrencies, NULL, status); 838 UResourceBundle *currency = ures_getByKeyWithFallback(currencies, keywordValue, NULL, status); 839 840 dispName = ures_getStringByIndex(currency, UCURRENCY_DISPLAY_NAME_INDEX, &dispNameLen, status); 841 842 /*close the bundles */ 843 ures_close(currency); 844 ures_close(currencies); 845 ures_close(bundle); 846 847 if(U_FAILURE(*status)){ 848 if(*status == U_MISSING_RESOURCE_ERROR){ 849 /* we just want to write the value over if nothing is available */ 850 *status = U_USING_DEFAULT_WARNING; 851 }else{ 852 return 0; 853 } 854 } 855 856 /* now copy the dispName over if not NULL */ 857 if(dispName != NULL){ 858 if(dispNameLen <= destCapacity){ 859 u_memcpy(dest, dispName, dispNameLen); 860 return u_terminateUChars(dest, destCapacity, dispNameLen, status); 861 }else{ 862 *status = U_BUFFER_OVERFLOW_ERROR; 863 return dispNameLen; 864 } 865 }else{ 866 /* we have not found the display name for the value .. just copy over */ 867 if(keywordValueLen <= destCapacity){ 868 u_charsToUChars(keywordValue, dest, keywordValueLen); 869 return u_terminateUChars(dest, destCapacity, keywordValueLen, status); 870 }else{ 871 *status = U_BUFFER_OVERFLOW_ERROR; 872 return keywordValueLen; 873 } 874 } 875 876 877 }else{ 878 879 return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale, 880 _kTypes, keyword, 881 keywordValue, 882 keywordValue, 883 dest, destCapacity, 884 status); 885 } 886 } 887
