1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 1997-2013, 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 _kScriptsStandAlone[] = "Scripts%stand-alone"; 281 static const char _kCountries[] = "Countries"; 282 static const char _kVariants[] = "Variants"; 283 static const char _kKeys[] = "Keys"; 284 static const char _kTypes[] = "Types"; 285 //static const char _kRootName[] = "root"; 286 static const char _kCurrency[] = "currency"; 287 static const char _kCurrencies[] = "Currencies"; 288 static const char _kLocaleDisplayPattern[] = "localeDisplayPattern"; 289 static const char _kPattern[] = "pattern"; 290 static const char _kSeparator[] = "separator"; 291 292 /* ### Display name **************************************************/ 293 294 static int32_t 295 _getStringOrCopyKey(const char *path, const char *locale, 296 const char *tableKey, 297 const char* subTableKey, 298 const char *itemKey, 299 const char *substitute, 300 UChar *dest, int32_t destCapacity, 301 UErrorCode *pErrorCode) { 302 const UChar *s = NULL; 303 int32_t length = 0; 304 305 if(itemKey==NULL) { 306 /* top-level item: normal resource bundle access */ 307 UResourceBundle *rb; 308 309 rb=ures_open(path, locale, pErrorCode); 310 311 if(U_SUCCESS(*pErrorCode)) { 312 s=ures_getStringByKey(rb, tableKey, &length, pErrorCode); 313 /* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */ 314 ures_close(rb); 315 } 316 } else { 317 /* Language code should not be a number. If it is, set the error code. */ 318 if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) { 319 *pErrorCode = U_MISSING_RESOURCE_ERROR; 320 } else { 321 /* second-level item, use special fallback */ 322 s=uloc_getTableStringWithFallback(path, locale, 323 tableKey, 324 subTableKey, 325 itemKey, 326 &length, 327 pErrorCode); 328 } 329 } 330 331 if(U_SUCCESS(*pErrorCode)) { 332 int32_t copyLength=uprv_min(length, destCapacity); 333 if(copyLength>0 && s != NULL) { 334 u_memcpy(dest, s, copyLength); 335 } 336 } else { 337 /* no string from a resource bundle: convert the substitute */ 338 length=(int32_t)uprv_strlen(substitute); 339 u_charsToUChars(substitute, dest, uprv_min(length, destCapacity)); 340 *pErrorCode=U_USING_DEFAULT_WARNING; 341 } 342 343 return u_terminateUChars(dest, destCapacity, length, pErrorCode); 344 } 345 346 typedef int32_t U_CALLCONV UDisplayNameGetter(const char *, char *, int32_t, UErrorCode *); 347 348 static int32_t 349 _getDisplayNameForComponent(const char *locale, 350 const char *displayLocale, 351 UChar *dest, int32_t destCapacity, 352 UDisplayNameGetter *getter, 353 const char *tag, 354 UErrorCode *pErrorCode) { 355 char localeBuffer[ULOC_FULLNAME_CAPACITY*4]; 356 int32_t length; 357 UErrorCode localStatus; 358 const char* root = NULL; 359 360 /* argument checking */ 361 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 362 return 0; 363 } 364 365 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 366 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 367 return 0; 368 } 369 370 localStatus = U_ZERO_ERROR; 371 length=(*getter)(locale, localeBuffer, sizeof(localeBuffer), &localStatus); 372 if(U_FAILURE(localStatus) || localStatus==U_STRING_NOT_TERMINATED_WARNING) { 373 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 374 return 0; 375 } 376 if(length==0) { 377 return u_terminateUChars(dest, destCapacity, 0, pErrorCode); 378 } 379 380 root = tag == _kCountries ? U_ICUDATA_REGION : U_ICUDATA_LANG; 381 382 return _getStringOrCopyKey(root, displayLocale, 383 tag, NULL, localeBuffer, 384 localeBuffer, 385 dest, destCapacity, 386 pErrorCode); 387 } 388 389 U_CAPI int32_t U_EXPORT2 390 uloc_getDisplayLanguage(const char *locale, 391 const char *displayLocale, 392 UChar *dest, int32_t destCapacity, 393 UErrorCode *pErrorCode) { 394 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 395 uloc_getLanguage, _kLanguages, pErrorCode); 396 } 397 398 U_CAPI int32_t U_EXPORT2 399 uloc_getDisplayScript(const char* locale, 400 const char* displayLocale, 401 UChar *dest, int32_t destCapacity, 402 UErrorCode *pErrorCode) 403 { 404 UErrorCode err = U_ZERO_ERROR; 405 int32_t res = _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 406 uloc_getScript, _kScriptsStandAlone, &err); 407 408 if ( err == U_USING_DEFAULT_WARNING ) { 409 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 410 uloc_getScript, _kScripts, pErrorCode); 411 } else { 412 *pErrorCode = err; 413 return res; 414 } 415 } 416 417 U_INTERNAL int32_t U_EXPORT2 418 uloc_getDisplayScriptInContext(const char* locale, 419 const char* displayLocale, 420 UChar *dest, int32_t destCapacity, 421 UErrorCode *pErrorCode) 422 { 423 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 424 uloc_getScript, _kScripts, pErrorCode); 425 } 426 427 U_CAPI int32_t U_EXPORT2 428 uloc_getDisplayCountry(const char *locale, 429 const char *displayLocale, 430 UChar *dest, int32_t destCapacity, 431 UErrorCode *pErrorCode) { 432 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 433 uloc_getCountry, _kCountries, pErrorCode); 434 } 435 436 /* 437 * TODO separate variant1_variant2_variant3... 438 * by getting each tag's display string and concatenating them with ", " 439 * in between - similar to uloc_getDisplayName() 440 */ 441 U_CAPI int32_t U_EXPORT2 442 uloc_getDisplayVariant(const char *locale, 443 const char *displayLocale, 444 UChar *dest, int32_t destCapacity, 445 UErrorCode *pErrorCode) { 446 return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, 447 uloc_getVariant, _kVariants, pErrorCode); 448 } 449 450 /* Instead of having a separate pass for 'special' patterns, reintegrate the two 451 * so we don't get bitten by preflight bugs again. We can be reasonably efficient 452 * without two separate code paths, this code isn't that performance-critical. 453 * 454 * This code is general enough to deal with patterns that have a prefix or swap the 455 * language and remainder components, since we gave developers enough rope to do such 456 * things if they futz with the pattern data. But since we don't give them a way to 457 * specify a pattern for arbitrary combinations of components, there's not much use in 458 * that. I don't think our data includes such patterns, the only variable I know if is 459 * whether there is a space before the open paren, or not. Oh, and zh uses different 460 * chars than the standard open/close paren (which ja and ko use, btw). 461 */ 462 U_CAPI int32_t U_EXPORT2 463 uloc_getDisplayName(const char *locale, 464 const char *displayLocale, 465 UChar *dest, int32_t destCapacity, 466 UErrorCode *pErrorCode) 467 { 468 static const UChar defaultSeparator[9] = { 0x007b, 0x0030, 0x007d, 0x002c, 0x0020, 0x007b, 0x0031, 0x007d, 0x0000 }; /* "{0}, {1}" */ 469 static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */ 470 static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */ 471 static const int32_t subLen = 3; 472 static const UChar defaultPattern[10] = { 473 0x007b, 0x0030, 0x007d, 0x0020, 0x0028, 0x007b, 0x0031, 0x007d, 0x0029, 0x0000 474 }; /* {0} ({1}) */ 475 static const int32_t defaultPatLen = 9; 476 static const int32_t defaultSub0Pos = 0; 477 static const int32_t defaultSub1Pos = 5; 478 479 int32_t length; /* of formatted result */ 480 481 const UChar *separator; 482 int32_t sepLen = 0; 483 const UChar *pattern; 484 int32_t patLen = 0; 485 int32_t sub0Pos, sub1Pos; 486 487 UChar formatOpenParen = 0x0028; // ( 488 UChar formatReplaceOpenParen = 0x005B; // [ 489 UChar formatCloseParen = 0x0029; // ) 490 UChar formatReplaceCloseParen = 0x005D; // ] 491 492 UBool haveLang = TRUE; /* assume true, set false if we find we don't have 493 a lang component in the locale */ 494 UBool haveRest = TRUE; /* assume true, set false if we find we don't have 495 any other component in the locale */ 496 UBool retry = FALSE; /* set true if we need to retry, see below */ 497 498 int32_t langi = 0; /* index of the language substitution (0 or 1), virtually always 0 */ 499 500 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 501 return 0; 502 } 503 504 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 505 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 506 return 0; 507 } 508 509 { 510 UErrorCode status = U_ZERO_ERROR; 511 UResourceBundle* locbundle=ures_open(U_ICUDATA_LANG, displayLocale, &status); 512 UResourceBundle* dspbundle=ures_getByKeyWithFallback(locbundle, _kLocaleDisplayPattern, 513 NULL, &status); 514 515 separator=ures_getStringByKeyWithFallback(dspbundle, _kSeparator, &sepLen, &status); 516 pattern=ures_getStringByKeyWithFallback(dspbundle, _kPattern, &patLen, &status); 517 518 ures_close(dspbundle); 519 ures_close(locbundle); 520 } 521 522 /* If we couldn't find any data, then use the defaults */ 523 if(sepLen == 0) { 524 separator = defaultSeparator; 525 } 526 /* #10244: Even though separator is now a pattern, it is awkward to handle it as such 527 * here since we are trying to build the display string in place in the dest buffer, 528 * and to handle it as a pattern would entail having separate storage for the 529 * substrings that need to be combined (the first of which may be the result of 530 * previous such combinations). So for now we continue to treat the portion between 531 * {0} and {1} as a string to be appended when joining substrings, ignoring anything 532 * that is before {0} or after {1} (no existing separator pattern has any such thing). 533 * This is similar to how pattern is handled below. 534 */ 535 { 536 UChar *p0=u_strstr(separator, sub0); 537 UChar *p1=u_strstr(separator, sub1); 538 if (p0==NULL || p1==NULL || p1<p0) { 539 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 540 return 0; 541 } 542 separator = (const UChar *)p0 + subLen; 543 sepLen = p1 - separator; 544 } 545 546 if(patLen==0 || (patLen==defaultPatLen && !u_strncmp(pattern, defaultPattern, patLen))) { 547 pattern=defaultPattern; 548 patLen=defaultPatLen; 549 sub0Pos=defaultSub0Pos; 550 sub1Pos=defaultSub1Pos; 551 // use default formatOpenParen etc. set above 552 } else { /* non-default pattern */ 553 UChar *p0=u_strstr(pattern, sub0); 554 UChar *p1=u_strstr(pattern, sub1); 555 if (p0==NULL || p1==NULL) { 556 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 557 return 0; 558 } 559 sub0Pos=p0-pattern; 560 sub1Pos=p1-pattern; 561 if (sub1Pos < sub0Pos) { /* a very odd pattern */ 562 int32_t t=sub0Pos; sub0Pos=sub1Pos; sub1Pos=t; 563 langi=1; 564 } 565 if (u_strchr(pattern, 0xFF08) != NULL) { 566 formatOpenParen = 0xFF08; // fullwidth ( 567 formatReplaceOpenParen = 0xFF3B; // fullwidth [ 568 formatCloseParen = 0xFF09; // fullwidth ) 569 formatReplaceCloseParen = 0xFF3D; // fullwidth ] 570 } 571 } 572 573 /* We loop here because there is one case in which after the first pass we could need to 574 * reextract the data. If there's initial padding before the first element, we put in 575 * the padding and then write that element. If it turns out there's no second element, 576 * we didn't need the padding. If we do need the data (no preflight), and the first element 577 * would have fit but for the padding, we need to reextract. In this case (only) we 578 * adjust the parameters so padding is not added, and repeat. 579 */ 580 do { 581 UChar* p=dest; 582 int32_t patPos=0; /* position in the pattern, used for non-substitution portions */ 583 int32_t langLen=0; /* length of language substitution */ 584 int32_t langPos=0; /* position in output of language substitution */ 585 int32_t restLen=0; /* length of 'everything else' substitution */ 586 int32_t restPos=0; /* position in output of 'everything else' substitution */ 587 UEnumeration* kenum = NULL; /* keyword enumeration */ 588 589 /* prefix of pattern, extremely likely to be empty */ 590 if(sub0Pos) { 591 if(destCapacity >= sub0Pos) { 592 while (patPos < sub0Pos) { 593 *p++ = pattern[patPos++]; 594 } 595 } else { 596 patPos=sub0Pos; 597 } 598 length=sub0Pos; 599 } else { 600 length=0; 601 } 602 603 for(int32_t subi=0,resti=0;subi<2;) { /* iterate through patterns 0 and 1*/ 604 UBool subdone = FALSE; /* set true when ready to move to next substitution */ 605 606 /* prep p and cap for calls to get display components, pin cap to 0 since 607 they complain if cap is negative */ 608 int32_t cap=destCapacity-length; 609 if (cap <= 0) { 610 cap=0; 611 } else { 612 p=dest+length; 613 } 614 615 if (subi == langi) { /* {0}*/ 616 if(haveLang) { 617 langPos=length; 618 langLen=uloc_getDisplayLanguage(locale, displayLocale, p, cap, pErrorCode); 619 length+=langLen; 620 haveLang=langLen>0; 621 } 622 subdone=TRUE; 623 } else { /* {1} */ 624 if(!haveRest) { 625 subdone=TRUE; 626 } else { 627 int32_t len; /* length of component (plus other stuff) we just fetched */ 628 switch(resti++) { 629 case 0: 630 restPos=length; 631 len=uloc_getDisplayScriptInContext(locale, displayLocale, p, cap, pErrorCode); 632 break; 633 case 1: 634 len=uloc_getDisplayCountry(locale, displayLocale, p, cap, pErrorCode); 635 break; 636 case 2: 637 len=uloc_getDisplayVariant(locale, displayLocale, p, cap, pErrorCode); 638 break; 639 case 3: 640 kenum = uloc_openKeywords(locale, pErrorCode); 641 /* fall through */ 642 default: { 643 const char* kw=uenum_next(kenum, &len, pErrorCode); 644 if (kw == NULL) { 645 uenum_close(kenum); 646 len=0; /* mark that we didn't add a component */ 647 subdone=TRUE; 648 } else { 649 /* incorporating this behavior into the loop made it even more complex, 650 so just special case it here */ 651 len = uloc_getDisplayKeyword(kw, displayLocale, p, cap, pErrorCode); 652 if(len) { 653 if(len < cap) { 654 p[len]=0x3d; /* '=', assume we'll need it */ 655 } 656 len+=1; 657 658 /* adjust for call to get keyword */ 659 cap-=len; 660 if(cap <= 0) { 661 cap=0; 662 } else { 663 p+=len; 664 } 665 } 666 /* reset for call below */ 667 if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) { 668 *pErrorCode=U_ZERO_ERROR; 669 } 670 int32_t vlen = uloc_getDisplayKeywordValue(locale, kw, displayLocale, 671 p, cap, pErrorCode); 672 if(len) { 673 if(vlen==0) { 674 --len; /* remove unneeded '=' */ 675 } 676 /* restore cap and p to what they were at start */ 677 cap=destCapacity-length; 678 if(cap <= 0) { 679 cap=0; 680 } else { 681 p=dest+length; 682 } 683 } 684 len+=vlen; /* total we added for key + '=' + value */ 685 } 686 } break; 687 } /* end switch */ 688 689 if (len>0) { 690 /* we addeed a component, so add separator and write it if there's room. */ 691 if(len+sepLen<=cap) { 692 const UChar * plimit = p + len; 693 for (; p < plimit; p++) { 694 if (*p == formatOpenParen) { 695 *p = formatReplaceOpenParen; 696 } else if (*p == formatCloseParen) { 697 *p = formatReplaceCloseParen; 698 } 699 } 700 for(int32_t i=0;i<sepLen;++i) { 701 *p++=separator[i]; 702 } 703 } 704 length+=len+sepLen; 705 } else if(subdone) { 706 /* remove separator if we added it */ 707 if (length!=restPos) { 708 length-=sepLen; 709 } 710 restLen=length-restPos; 711 haveRest=restLen>0; 712 } 713 } 714 } 715 716 if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) { 717 *pErrorCode=U_ZERO_ERROR; 718 } 719 720 if(subdone) { 721 if(haveLang && haveRest) { 722 /* append internal portion of pattern, the first time, 723 or last portion of pattern the second time */ 724 int32_t padLen; 725 patPos+=subLen; 726 padLen=(subi==0 ? sub1Pos : patLen)-patPos; 727 if(length+padLen < destCapacity) { 728 p=dest+length; 729 for(int32_t i=0;i<padLen;++i) { 730 *p++=pattern[patPos++]; 731 } 732 } else { 733 patPos+=padLen; 734 } 735 length+=padLen; 736 } else if(subi==0) { 737 /* don't have first component, reset for second component */ 738 sub0Pos=0; 739 length=0; 740 } else if(length>0) { 741 /* true length is the length of just the component we got. */ 742 length=haveLang?langLen:restLen; 743 if(dest && sub0Pos!=0) { 744 if (sub0Pos+length<=destCapacity) { 745 /* first component not at start of result, 746 but we have full component in buffer. */ 747 u_memmove(dest, dest+(haveLang?langPos:restPos), length); 748 } else { 749 /* would have fit, but didn't because of pattern prefix. */ 750 sub0Pos=0; /* stops initial padding (and a second retry, 751 so we won't end up here again) */ 752 retry=TRUE; 753 } 754 } 755 } 756 757 ++subi; /* move on to next substitution */ 758 } 759 } 760 } while(retry); 761 762 return u_terminateUChars(dest, destCapacity, length, pErrorCode); 763 } 764 765 U_CAPI int32_t U_EXPORT2 766 uloc_getDisplayKeyword(const char* keyword, 767 const char* displayLocale, 768 UChar* dest, 769 int32_t destCapacity, 770 UErrorCode* status){ 771 772 /* argument checking */ 773 if(status==NULL || U_FAILURE(*status)) { 774 return 0; 775 } 776 777 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 778 *status=U_ILLEGAL_ARGUMENT_ERROR; 779 return 0; 780 } 781 782 783 /* pass itemKey=NULL to look for a top-level item */ 784 return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale, 785 _kKeys, NULL, 786 keyword, 787 keyword, 788 dest, destCapacity, 789 status); 790 791 } 792 793 794 #define UCURRENCY_DISPLAY_NAME_INDEX 1 795 796 U_CAPI int32_t U_EXPORT2 797 uloc_getDisplayKeywordValue( const char* locale, 798 const char* keyword, 799 const char* displayLocale, 800 UChar* dest, 801 int32_t destCapacity, 802 UErrorCode* status){ 803 804 805 char keywordValue[ULOC_FULLNAME_CAPACITY*4]; 806 int32_t capacity = ULOC_FULLNAME_CAPACITY*4; 807 int32_t keywordValueLen =0; 808 809 /* argument checking */ 810 if(status==NULL || U_FAILURE(*status)) { 811 return 0; 812 } 813 814 if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { 815 *status=U_ILLEGAL_ARGUMENT_ERROR; 816 return 0; 817 } 818 819 /* get the keyword value */ 820 keywordValue[0]=0; 821 keywordValueLen = uloc_getKeywordValue(locale, keyword, keywordValue, capacity, status); 822 823 /* 824 * if the keyword is equal to currency .. then to get the display name 825 * we need to do the fallback ourselves 826 */ 827 if(uprv_stricmp(keyword, _kCurrency)==0){ 828 829 int32_t dispNameLen = 0; 830 const UChar *dispName = NULL; 831 832 UResourceBundle *bundle = ures_open(U_ICUDATA_CURR, displayLocale, status); 833 UResourceBundle *currencies = ures_getByKey(bundle, _kCurrencies, NULL, status); 834 UResourceBundle *currency = ures_getByKeyWithFallback(currencies, keywordValue, NULL, status); 835 836 dispName = ures_getStringByIndex(currency, UCURRENCY_DISPLAY_NAME_INDEX, &dispNameLen, status); 837 838 /*close the bundles */ 839 ures_close(currency); 840 ures_close(currencies); 841 ures_close(bundle); 842 843 if(U_FAILURE(*status)){ 844 if(*status == U_MISSING_RESOURCE_ERROR){ 845 /* we just want to write the value over if nothing is available */ 846 *status = U_USING_DEFAULT_WARNING; 847 }else{ 848 return 0; 849 } 850 } 851 852 /* now copy the dispName over if not NULL */ 853 if(dispName != NULL){ 854 if(dispNameLen <= destCapacity){ 855 uprv_memcpy(dest, dispName, dispNameLen * U_SIZEOF_UCHAR); 856 return u_terminateUChars(dest, destCapacity, dispNameLen, status); 857 }else{ 858 *status = U_BUFFER_OVERFLOW_ERROR; 859 return dispNameLen; 860 } 861 }else{ 862 /* we have not found the display name for the value .. just copy over */ 863 if(keywordValueLen <= destCapacity){ 864 u_charsToUChars(keywordValue, dest, keywordValueLen); 865 return u_terminateUChars(dest, destCapacity, keywordValueLen, status); 866 }else{ 867 *status = U_BUFFER_OVERFLOW_ERROR; 868 return keywordValueLen; 869 } 870 } 871 872 873 }else{ 874 875 return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale, 876 _kTypes, keyword, 877 keywordValue, 878 keywordValue, 879 dest, destCapacity, 880 status); 881 } 882 } 883
