1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ********************************************************************** 5 * Copyright (C) 2009-2015, International Business Machines 6 * Corporation and others. All Rights Reserved. 7 ********************************************************************** 8 */ 9 10 #include "unicode/utypes.h" 11 #include "unicode/ures.h" 12 #include "unicode/putil.h" 13 #include "unicode/uloc.h" 14 #include "ustr_imp.h" 15 #include "cmemory.h" 16 #include "cstring.h" 17 #include "putilimp.h" 18 #include "uinvchar.h" 19 #include "ulocimp.h" 20 #include "uassert.h" 21 22 23 /* struct holding a single variant */ 24 typedef struct VariantListEntry { 25 const char *variant; 26 struct VariantListEntry *next; 27 } VariantListEntry; 28 29 /* struct holding a single attribute value */ 30 typedef struct AttributeListEntry { 31 const char *attribute; 32 struct AttributeListEntry *next; 33 } AttributeListEntry; 34 35 /* struct holding a single extension */ 36 typedef struct ExtensionListEntry { 37 const char *key; 38 const char *value; 39 struct ExtensionListEntry *next; 40 } ExtensionListEntry; 41 42 #define MAXEXTLANG 3 43 typedef struct ULanguageTag { 44 char *buf; /* holding parsed subtags */ 45 const char *language; 46 const char *extlang[MAXEXTLANG]; 47 const char *script; 48 const char *region; 49 VariantListEntry *variants; 50 ExtensionListEntry *extensions; 51 const char *privateuse; 52 const char *grandfathered; 53 } ULanguageTag; 54 55 #define MINLEN 2 56 #define SEP '-' 57 #define PRIVATEUSE 'x' 58 #define LDMLEXT 'u' 59 60 #define LOCALE_SEP '_' 61 #define LOCALE_EXT_SEP '@' 62 #define LOCALE_KEYWORD_SEP ';' 63 #define LOCALE_KEY_TYPE_SEP '=' 64 65 #define ISALPHA(c) uprv_isASCIILetter(c) 66 #define ISNUMERIC(c) ((c)>='0' && (c)<='9') 67 68 static const char EMPTY[] = ""; 69 static const char LANG_UND[] = "und"; 70 static const char PRIVATEUSE_KEY[] = "x"; 71 static const char _POSIX[] = "_POSIX"; 72 static const char POSIX_KEY[] = "va"; 73 static const char POSIX_VALUE[] = "posix"; 74 static const char LOCALE_ATTRIBUTE_KEY[] = "attribute"; 75 static const char PRIVUSE_VARIANT_PREFIX[] = "lvariant"; 76 static const char LOCALE_TYPE_YES[] = "yes"; 77 78 #define LANG_UND_LEN 3 79 80 static const char* const GRANDFATHERED[] = { 81 /* grandfathered preferred */ 82 "art-lojban", "jbo", 83 "cel-gaulish", "xtg-x-cel-gaulish", 84 "en-GB-oed", "en-GB-x-oed", 85 "i-ami", "ami", 86 "i-bnn", "bnn", 87 "i-default", "en-x-i-default", 88 "i-enochian", "und-x-i-enochian", 89 "i-hak", "hak", 90 "i-klingon", "tlh", 91 "i-lux", "lb", 92 "i-mingo", "see-x-i-mingo", 93 "i-navajo", "nv", 94 "i-pwn", "pwn", 95 "i-tao", "tao", 96 "i-tay", "tay", 97 "i-tsu", "tsu", 98 "no-bok", "nb", 99 "no-nyn", "nn", 100 "sgn-be-fr", "sfb", 101 "sgn-be-nl", "vgt", 102 "sgn-ch-de", "sgg", 103 "zh-guoyu", "cmn", 104 "zh-hakka", "hak", 105 "zh-min", "nan-x-zh-min", 106 "zh-min-nan", "nan", 107 "zh-xiang", "hsn", 108 NULL, NULL 109 }; 110 111 static const char DEPRECATEDLANGS[][4] = { 112 /* deprecated new */ 113 "iw", "he", 114 "ji", "yi", 115 "in", "id" 116 }; 117 118 /* 119 * ------------------------------------------------- 120 * 121 * These ultag_ functions may be exposed as APIs later 122 * 123 * ------------------------------------------------- 124 */ 125 126 static ULanguageTag* 127 ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* status); 128 129 static void 130 ultag_close(ULanguageTag* langtag); 131 132 static const char* 133 ultag_getLanguage(const ULanguageTag* langtag); 134 135 #if 0 136 static const char* 137 ultag_getJDKLanguage(const ULanguageTag* langtag); 138 #endif 139 140 static const char* 141 ultag_getExtlang(const ULanguageTag* langtag, int32_t idx); 142 143 static int32_t 144 ultag_getExtlangSize(const ULanguageTag* langtag); 145 146 static const char* 147 ultag_getScript(const ULanguageTag* langtag); 148 149 static const char* 150 ultag_getRegion(const ULanguageTag* langtag); 151 152 static const char* 153 ultag_getVariant(const ULanguageTag* langtag, int32_t idx); 154 155 static int32_t 156 ultag_getVariantsSize(const ULanguageTag* langtag); 157 158 static const char* 159 ultag_getExtensionKey(const ULanguageTag* langtag, int32_t idx); 160 161 static const char* 162 ultag_getExtensionValue(const ULanguageTag* langtag, int32_t idx); 163 164 static int32_t 165 ultag_getExtensionsSize(const ULanguageTag* langtag); 166 167 static const char* 168 ultag_getPrivateUse(const ULanguageTag* langtag); 169 170 #if 0 171 static const char* 172 ultag_getGrandfathered(const ULanguageTag* langtag); 173 #endif 174 175 /* 176 * ------------------------------------------------- 177 * 178 * Language subtag syntax validation functions 179 * 180 * ------------------------------------------------- 181 */ 182 183 static UBool 184 _isAlphaString(const char* s, int32_t len) { 185 int32_t i; 186 for (i = 0; i < len; i++) { 187 if (!ISALPHA(*(s + i))) { 188 return FALSE; 189 } 190 } 191 return TRUE; 192 } 193 194 static UBool 195 _isNumericString(const char* s, int32_t len) { 196 int32_t i; 197 for (i = 0; i < len; i++) { 198 if (!ISNUMERIC(*(s + i))) { 199 return FALSE; 200 } 201 } 202 return TRUE; 203 } 204 205 static UBool 206 _isAlphaNumericString(const char* s, int32_t len) { 207 int32_t i; 208 for (i = 0; i < len; i++) { 209 if (!ISALPHA(*(s + i)) && !ISNUMERIC(*(s + i))) { 210 return FALSE; 211 } 212 } 213 return TRUE; 214 } 215 216 static UBool 217 _isLanguageSubtag(const char* s, int32_t len) { 218 /* 219 * language = 2*3ALPHA ; shortest ISO 639 code 220 * ["-" extlang] ; sometimes followed by 221 * ; extended language subtags 222 * / 4ALPHA ; or reserved for future use 223 * / 5*8ALPHA ; or registered language subtag 224 */ 225 if (len < 0) { 226 len = (int32_t)uprv_strlen(s); 227 } 228 if (len >= 2 && len <= 8 && _isAlphaString(s, len)) { 229 return TRUE; 230 } 231 return FALSE; 232 } 233 234 static UBool 235 _isExtlangSubtag(const char* s, int32_t len) { 236 /* 237 * extlang = 3ALPHA ; selected ISO 639 codes 238 * *2("-" 3ALPHA) ; permanently reserved 239 */ 240 if (len < 0) { 241 len = (int32_t)uprv_strlen(s); 242 } 243 if (len == 3 && _isAlphaString(s, len)) { 244 return TRUE; 245 } 246 return FALSE; 247 } 248 249 static UBool 250 _isScriptSubtag(const char* s, int32_t len) { 251 /* 252 * script = 4ALPHA ; ISO 15924 code 253 */ 254 if (len < 0) { 255 len = (int32_t)uprv_strlen(s); 256 } 257 if (len == 4 && _isAlphaString(s, len)) { 258 return TRUE; 259 } 260 return FALSE; 261 } 262 263 static UBool 264 _isRegionSubtag(const char* s, int32_t len) { 265 /* 266 * region = 2ALPHA ; ISO 3166-1 code 267 * / 3DIGIT ; UN M.49 code 268 */ 269 if (len < 0) { 270 len = (int32_t)uprv_strlen(s); 271 } 272 if (len == 2 && _isAlphaString(s, len)) { 273 return TRUE; 274 } 275 if (len == 3 && _isNumericString(s, len)) { 276 return TRUE; 277 } 278 return FALSE; 279 } 280 281 static UBool 282 _isVariantSubtag(const char* s, int32_t len) { 283 /* 284 * variant = 5*8alphanum ; registered variants 285 * / (DIGIT 3alphanum) 286 */ 287 if (len < 0) { 288 len = (int32_t)uprv_strlen(s); 289 } 290 if (len >= 5 && len <= 8 && _isAlphaNumericString(s, len)) { 291 return TRUE; 292 } 293 if (len == 4 && ISNUMERIC(*s) && _isAlphaNumericString(s + 1, 3)) { 294 return TRUE; 295 } 296 return FALSE; 297 } 298 299 static UBool 300 _isPrivateuseVariantSubtag(const char* s, int32_t len) { 301 /* 302 * variant = 1*8alphanum ; registered variants 303 * / (DIGIT 3alphanum) 304 */ 305 if (len < 0) { 306 len = (int32_t)uprv_strlen(s); 307 } 308 if (len >= 1 && len <= 8 && _isAlphaNumericString(s, len)) { 309 return TRUE; 310 } 311 return FALSE; 312 } 313 314 static UBool 315 _isExtensionSingleton(const char* s, int32_t len) { 316 /* 317 * extension = singleton 1*("-" (2*8alphanum)) 318 */ 319 if (len < 0) { 320 len = (int32_t)uprv_strlen(s); 321 } 322 if (len == 1 && ISALPHA(*s) && (uprv_tolower(*s) != PRIVATEUSE)) { 323 return TRUE; 324 } 325 return FALSE; 326 } 327 328 static UBool 329 _isExtensionSubtag(const char* s, int32_t len) { 330 /* 331 * extension = singleton 1*("-" (2*8alphanum)) 332 */ 333 if (len < 0) { 334 len = (int32_t)uprv_strlen(s); 335 } 336 if (len >= 2 && len <= 8 && _isAlphaNumericString(s, len)) { 337 return TRUE; 338 } 339 return FALSE; 340 } 341 342 static UBool 343 _isExtensionSubtags(const char* s, int32_t len) { 344 const char *p = s; 345 const char *pSubtag = NULL; 346 347 if (len < 0) { 348 len = (int32_t)uprv_strlen(s); 349 } 350 351 while ((p - s) < len) { 352 if (*p == SEP) { 353 if (pSubtag == NULL) { 354 return FALSE; 355 } 356 if (!_isExtensionSubtag(pSubtag, (int32_t)(p - pSubtag))) { 357 return FALSE; 358 } 359 pSubtag = NULL; 360 } else if (pSubtag == NULL) { 361 pSubtag = p; 362 } 363 p++; 364 } 365 if (pSubtag == NULL) { 366 return FALSE; 367 } 368 return _isExtensionSubtag(pSubtag, (int32_t)(p - pSubtag)); 369 } 370 371 static UBool 372 _isPrivateuseValueSubtag(const char* s, int32_t len) { 373 /* 374 * privateuse = "x" 1*("-" (1*8alphanum)) 375 */ 376 if (len < 0) { 377 len = (int32_t)uprv_strlen(s); 378 } 379 if (len >= 1 && len <= 8 && _isAlphaNumericString(s, len)) { 380 return TRUE; 381 } 382 return FALSE; 383 } 384 385 static UBool 386 _isPrivateuseValueSubtags(const char* s, int32_t len) { 387 const char *p = s; 388 const char *pSubtag = NULL; 389 390 if (len < 0) { 391 len = (int32_t)uprv_strlen(s); 392 } 393 394 while ((p - s) < len) { 395 if (*p == SEP) { 396 if (pSubtag == NULL) { 397 return FALSE; 398 } 399 if (!_isPrivateuseValueSubtag(pSubtag, (int32_t)(p - pSubtag))) { 400 return FALSE; 401 } 402 pSubtag = NULL; 403 } else if (pSubtag == NULL) { 404 pSubtag = p; 405 } 406 p++; 407 } 408 if (pSubtag == NULL) { 409 return FALSE; 410 } 411 return _isPrivateuseValueSubtag(pSubtag, (int32_t)(p - pSubtag)); 412 } 413 414 U_CFUNC UBool 415 ultag_isUnicodeLocaleKey(const char* s, int32_t len) { 416 if (len < 0) { 417 len = (int32_t)uprv_strlen(s); 418 } 419 if (len == 2 && _isAlphaNumericString(s, len)) { 420 return TRUE; 421 } 422 return FALSE; 423 } 424 425 U_CFUNC UBool 426 ultag_isUnicodeLocaleType(const char*s, int32_t len) { 427 const char* p; 428 int32_t subtagLen = 0; 429 430 if (len < 0) { 431 len = (int32_t)uprv_strlen(s); 432 } 433 434 for (p = s; len > 0; p++, len--) { 435 if (*p == SEP) { 436 if (subtagLen < 3) { 437 return FALSE; 438 } 439 subtagLen = 0; 440 } else if (ISALPHA(*p) || ISNUMERIC(*p)) { 441 subtagLen++; 442 if (subtagLen > 8) { 443 return FALSE; 444 } 445 } else { 446 return FALSE; 447 } 448 } 449 450 return (subtagLen >= 3); 451 } 452 /* 453 * ------------------------------------------------- 454 * 455 * Helper functions 456 * 457 * ------------------------------------------------- 458 */ 459 460 static UBool 461 _addVariantToList(VariantListEntry **first, VariantListEntry *var) { 462 UBool bAdded = TRUE; 463 464 if (*first == NULL) { 465 var->next = NULL; 466 *first = var; 467 } else { 468 VariantListEntry *prev, *cur; 469 int32_t cmp; 470 471 /* variants order should be preserved */ 472 prev = NULL; 473 cur = *first; 474 while (TRUE) { 475 if (cur == NULL) { 476 prev->next = var; 477 var->next = NULL; 478 break; 479 } 480 481 /* Checking for duplicate variant */ 482 cmp = uprv_compareInvCharsAsAscii(var->variant, cur->variant); 483 if (cmp == 0) { 484 /* duplicated variant */ 485 bAdded = FALSE; 486 break; 487 } 488 prev = cur; 489 cur = cur->next; 490 } 491 } 492 493 return bAdded; 494 } 495 496 static UBool 497 _addAttributeToList(AttributeListEntry **first, AttributeListEntry *attr) { 498 UBool bAdded = TRUE; 499 500 if (*first == NULL) { 501 attr->next = NULL; 502 *first = attr; 503 } else { 504 AttributeListEntry *prev, *cur; 505 int32_t cmp; 506 507 /* reorder variants in alphabetical order */ 508 prev = NULL; 509 cur = *first; 510 while (TRUE) { 511 if (cur == NULL) { 512 prev->next = attr; 513 attr->next = NULL; 514 break; 515 } 516 cmp = uprv_compareInvCharsAsAscii(attr->attribute, cur->attribute); 517 if (cmp < 0) { 518 if (prev == NULL) { 519 *first = attr; 520 } else { 521 prev->next = attr; 522 } 523 attr->next = cur; 524 break; 525 } 526 if (cmp == 0) { 527 /* duplicated variant */ 528 bAdded = FALSE; 529 break; 530 } 531 prev = cur; 532 cur = cur->next; 533 } 534 } 535 536 return bAdded; 537 } 538 539 540 static UBool 541 _addExtensionToList(ExtensionListEntry **first, ExtensionListEntry *ext, UBool localeToBCP) { 542 UBool bAdded = TRUE; 543 544 if (*first == NULL) { 545 ext->next = NULL; 546 *first = ext; 547 } else { 548 ExtensionListEntry *prev, *cur; 549 int32_t cmp; 550 551 /* reorder variants in alphabetical order */ 552 prev = NULL; 553 cur = *first; 554 while (TRUE) { 555 if (cur == NULL) { 556 prev->next = ext; 557 ext->next = NULL; 558 break; 559 } 560 if (localeToBCP) { 561 /* special handling for locale to bcp conversion */ 562 int32_t len, curlen; 563 564 len = (int32_t)uprv_strlen(ext->key); 565 curlen = (int32_t)uprv_strlen(cur->key); 566 567 if (len == 1 && curlen == 1) { 568 if (*(ext->key) == *(cur->key)) { 569 cmp = 0; 570 } else if (*(ext->key) == PRIVATEUSE) { 571 cmp = 1; 572 } else if (*(cur->key) == PRIVATEUSE) { 573 cmp = -1; 574 } else { 575 cmp = *(ext->key) - *(cur->key); 576 } 577 } else if (len == 1) { 578 cmp = *(ext->key) - LDMLEXT; 579 } else if (curlen == 1) { 580 cmp = LDMLEXT - *(cur->key); 581 } else { 582 cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); 583 /* Both are u extension keys - we need special handling for 'attribute' */ 584 if (cmp != 0) { 585 if (uprv_strcmp(cur->key, LOCALE_ATTRIBUTE_KEY) == 0) { 586 cmp = 1; 587 } else if (uprv_strcmp(ext->key, LOCALE_ATTRIBUTE_KEY) == 0) { 588 cmp = -1; 589 } 590 } 591 } 592 } else { 593 cmp = uprv_compareInvCharsAsAscii(ext->key, cur->key); 594 } 595 if (cmp < 0) { 596 if (prev == NULL) { 597 *first = ext; 598 } else { 599 prev->next = ext; 600 } 601 ext->next = cur; 602 break; 603 } 604 if (cmp == 0) { 605 /* duplicated extension key */ 606 bAdded = FALSE; 607 break; 608 } 609 prev = cur; 610 cur = cur->next; 611 } 612 } 613 614 return bAdded; 615 } 616 617 static void 618 _initializeULanguageTag(ULanguageTag* langtag) { 619 int32_t i; 620 621 langtag->buf = NULL; 622 623 langtag->language = EMPTY; 624 for (i = 0; i < MAXEXTLANG; i++) { 625 langtag->extlang[i] = NULL; 626 } 627 628 langtag->script = EMPTY; 629 langtag->region = EMPTY; 630 631 langtag->variants = NULL; 632 langtag->extensions = NULL; 633 634 langtag->grandfathered = EMPTY; 635 langtag->privateuse = EMPTY; 636 } 637 638 static int32_t 639 _appendLanguageToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UErrorCode* status) { 640 char buf[ULOC_LANG_CAPACITY]; 641 UErrorCode tmpStatus = U_ZERO_ERROR; 642 int32_t len, i; 643 int32_t reslen = 0; 644 645 if (U_FAILURE(*status)) { 646 return 0; 647 } 648 649 len = uloc_getLanguage(localeID, buf, sizeof(buf), &tmpStatus); 650 if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { 651 if (strict) { 652 *status = U_ILLEGAL_ARGUMENT_ERROR; 653 return 0; 654 } 655 len = 0; 656 } 657 658 /* Note: returned language code is in lower case letters */ 659 660 if (len == 0) { 661 if (reslen < capacity) { 662 uprv_memcpy(appendAt + reslen, LANG_UND, uprv_min(LANG_UND_LEN, capacity - reslen)); 663 } 664 reslen += LANG_UND_LEN; 665 } else if (!_isLanguageSubtag(buf, len)) { 666 /* invalid language code */ 667 if (strict) { 668 *status = U_ILLEGAL_ARGUMENT_ERROR; 669 return 0; 670 } 671 if (reslen < capacity) { 672 uprv_memcpy(appendAt + reslen, LANG_UND, uprv_min(LANG_UND_LEN, capacity - reslen)); 673 } 674 reslen += LANG_UND_LEN; 675 } else { 676 /* resolve deprecated */ 677 for (i = 0; i < UPRV_LENGTHOF(DEPRECATEDLANGS); i += 2) { 678 if (uprv_compareInvCharsAsAscii(buf, DEPRECATEDLANGS[i]) == 0) { 679 uprv_strcpy(buf, DEPRECATEDLANGS[i + 1]); 680 len = (int32_t)uprv_strlen(buf); 681 break; 682 } 683 } 684 if (reslen < capacity) { 685 uprv_memcpy(appendAt + reslen, buf, uprv_min(len, capacity - reslen)); 686 } 687 reslen += len; 688 } 689 u_terminateChars(appendAt, capacity, reslen, status); 690 return reslen; 691 } 692 693 static int32_t 694 _appendScriptToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UErrorCode* status) { 695 char buf[ULOC_SCRIPT_CAPACITY]; 696 UErrorCode tmpStatus = U_ZERO_ERROR; 697 int32_t len; 698 int32_t reslen = 0; 699 700 if (U_FAILURE(*status)) { 701 return 0; 702 } 703 704 len = uloc_getScript(localeID, buf, sizeof(buf), &tmpStatus); 705 if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { 706 if (strict) { 707 *status = U_ILLEGAL_ARGUMENT_ERROR; 708 } 709 return 0; 710 } 711 712 if (len > 0) { 713 if (!_isScriptSubtag(buf, len)) { 714 /* invalid script code */ 715 if (strict) { 716 *status = U_ILLEGAL_ARGUMENT_ERROR; 717 } 718 return 0; 719 } else { 720 if (reslen < capacity) { 721 *(appendAt + reslen) = SEP; 722 } 723 reslen++; 724 725 if (reslen < capacity) { 726 uprv_memcpy(appendAt + reslen, buf, uprv_min(len, capacity - reslen)); 727 } 728 reslen += len; 729 } 730 } 731 u_terminateChars(appendAt, capacity, reslen, status); 732 return reslen; 733 } 734 735 static int32_t 736 _appendRegionToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UErrorCode* status) { 737 char buf[ULOC_COUNTRY_CAPACITY]; 738 UErrorCode tmpStatus = U_ZERO_ERROR; 739 int32_t len; 740 int32_t reslen = 0; 741 742 if (U_FAILURE(*status)) { 743 return 0; 744 } 745 746 len = uloc_getCountry(localeID, buf, sizeof(buf), &tmpStatus); 747 if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { 748 if (strict) { 749 *status = U_ILLEGAL_ARGUMENT_ERROR; 750 } 751 return 0; 752 } 753 754 if (len > 0) { 755 if (!_isRegionSubtag(buf, len)) { 756 /* invalid region code */ 757 if (strict) { 758 *status = U_ILLEGAL_ARGUMENT_ERROR; 759 } 760 return 0; 761 } else { 762 if (reslen < capacity) { 763 *(appendAt + reslen) = SEP; 764 } 765 reslen++; 766 767 if (reslen < capacity) { 768 uprv_memcpy(appendAt + reslen, buf, uprv_min(len, capacity - reslen)); 769 } 770 reslen += len; 771 } 772 } 773 u_terminateChars(appendAt, capacity, reslen, status); 774 return reslen; 775 } 776 777 static int32_t 778 _appendVariantsToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UBool *hadPosix, UErrorCode* status) { 779 char buf[ULOC_FULLNAME_CAPACITY]; 780 UErrorCode tmpStatus = U_ZERO_ERROR; 781 int32_t len, i; 782 int32_t reslen = 0; 783 784 if (U_FAILURE(*status)) { 785 return 0; 786 } 787 788 len = uloc_getVariant(localeID, buf, sizeof(buf), &tmpStatus); 789 if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { 790 if (strict) { 791 *status = U_ILLEGAL_ARGUMENT_ERROR; 792 } 793 return 0; 794 } 795 796 if (len > 0) { 797 char *p, *pVar; 798 UBool bNext = TRUE; 799 VariantListEntry *var; 800 VariantListEntry *varFirst = NULL; 801 802 pVar = NULL; 803 p = buf; 804 while (bNext) { 805 if (*p == SEP || *p == LOCALE_SEP || *p == 0) { 806 if (*p == 0) { 807 bNext = FALSE; 808 } else { 809 *p = 0; /* terminate */ 810 } 811 if (pVar == NULL) { 812 if (strict) { 813 *status = U_ILLEGAL_ARGUMENT_ERROR; 814 break; 815 } 816 /* ignore empty variant */ 817 } else { 818 /* ICU uses upper case letters for variants, but 819 the canonical format is lowercase in BCP47 */ 820 for (i = 0; *(pVar + i) != 0; i++) { 821 *(pVar + i) = uprv_tolower(*(pVar + i)); 822 } 823 824 /* validate */ 825 if (_isVariantSubtag(pVar, -1)) { 826 if (uprv_strcmp(pVar,POSIX_VALUE) || len != (int32_t)uprv_strlen(POSIX_VALUE)) { 827 /* emit the variant to the list */ 828 var = (VariantListEntry*)uprv_malloc(sizeof(VariantListEntry)); 829 if (var == NULL) { 830 *status = U_MEMORY_ALLOCATION_ERROR; 831 break; 832 } 833 var->variant = pVar; 834 if (!_addVariantToList(&varFirst, var)) { 835 /* duplicated variant */ 836 uprv_free(var); 837 if (strict) { 838 *status = U_ILLEGAL_ARGUMENT_ERROR; 839 break; 840 } 841 } 842 } else { 843 /* Special handling for POSIX variant, need to remember that we had it and then */ 844 /* treat it like an extension later. */ 845 *hadPosix = TRUE; 846 } 847 } else if (strict) { 848 *status = U_ILLEGAL_ARGUMENT_ERROR; 849 break; 850 } else if (_isPrivateuseValueSubtag(pVar, -1)) { 851 /* Handle private use subtags separately */ 852 break; 853 } 854 } 855 /* reset variant starting position */ 856 pVar = NULL; 857 } else if (pVar == NULL) { 858 pVar = p; 859 } 860 p++; 861 } 862 863 if (U_SUCCESS(*status)) { 864 if (varFirst != NULL) { 865 int32_t varLen; 866 867 /* write out validated/normalized variants to the target */ 868 var = varFirst; 869 while (var != NULL) { 870 if (reslen < capacity) { 871 *(appendAt + reslen) = SEP; 872 } 873 reslen++; 874 varLen = (int32_t)uprv_strlen(var->variant); 875 if (reslen < capacity) { 876 uprv_memcpy(appendAt + reslen, var->variant, uprv_min(varLen, capacity - reslen)); 877 } 878 reslen += varLen; 879 var = var->next; 880 } 881 } 882 } 883 884 /* clean up */ 885 var = varFirst; 886 while (var != NULL) { 887 VariantListEntry *tmpVar = var->next; 888 uprv_free(var); 889 var = tmpVar; 890 } 891 892 if (U_FAILURE(*status)) { 893 return 0; 894 } 895 } 896 897 u_terminateChars(appendAt, capacity, reslen, status); 898 return reslen; 899 } 900 901 static int32_t 902 _appendKeywordsToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UBool hadPosix, UErrorCode* status) { 903 char buf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; 904 char attrBuf[ULOC_KEYWORD_AND_VALUES_CAPACITY] = { 0 }; 905 int32_t attrBufLength = 0; 906 UEnumeration *keywordEnum = NULL; 907 int32_t reslen = 0; 908 909 keywordEnum = uloc_openKeywords(localeID, status); 910 if (U_FAILURE(*status) && !hadPosix) { 911 uenum_close(keywordEnum); 912 return 0; 913 } 914 if (keywordEnum != NULL || hadPosix) { 915 /* reorder extensions */ 916 int32_t len; 917 const char *key; 918 ExtensionListEntry *firstExt = NULL; 919 ExtensionListEntry *ext; 920 AttributeListEntry *firstAttr = NULL; 921 AttributeListEntry *attr; 922 char *attrValue; 923 char extBuf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; 924 char *pExtBuf = extBuf; 925 int32_t extBufCapacity = sizeof(extBuf); 926 const char *bcpKey=nullptr, *bcpValue=nullptr; 927 UErrorCode tmpStatus = U_ZERO_ERROR; 928 int32_t keylen; 929 UBool isBcpUExt; 930 931 while (TRUE) { 932 key = uenum_next(keywordEnum, NULL, status); 933 if (key == NULL) { 934 break; 935 } 936 len = uloc_getKeywordValue(localeID, key, buf, sizeof(buf), &tmpStatus); 937 /* buf must be null-terminated */ 938 if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { 939 if (strict) { 940 *status = U_ILLEGAL_ARGUMENT_ERROR; 941 break; 942 } 943 /* ignore this keyword */ 944 tmpStatus = U_ZERO_ERROR; 945 continue; 946 } 947 948 keylen = (int32_t)uprv_strlen(key); 949 isBcpUExt = (keylen > 1); 950 951 /* special keyword used for representing Unicode locale attributes */ 952 if (uprv_strcmp(key, LOCALE_ATTRIBUTE_KEY) == 0) { 953 if (len > 0) { 954 int32_t i = 0; 955 while (TRUE) { 956 attrBufLength = 0; 957 for (; i < len; i++) { 958 if (buf[i] != '-') { 959 attrBuf[attrBufLength++] = buf[i]; 960 } else { 961 i++; 962 break; 963 } 964 } 965 if (attrBufLength > 0) { 966 attrBuf[attrBufLength] = 0; 967 968 } else if (i >= len){ 969 break; 970 } 971 972 /* create AttributeListEntry */ 973 attr = (AttributeListEntry*)uprv_malloc(sizeof(AttributeListEntry)); 974 if (attr == NULL) { 975 *status = U_MEMORY_ALLOCATION_ERROR; 976 break; 977 } 978 attrValue = (char*)uprv_malloc(attrBufLength + 1); 979 if (attrValue == NULL) { 980 *status = U_MEMORY_ALLOCATION_ERROR; 981 break; 982 } 983 uprv_strcpy(attrValue, attrBuf); 984 attr->attribute = attrValue; 985 986 if (!_addAttributeToList(&firstAttr, attr)) { 987 uprv_free(attr); 988 uprv_free(attrValue); 989 if (strict) { 990 *status = U_ILLEGAL_ARGUMENT_ERROR; 991 break; 992 } 993 } 994 } 995 /* for a place holder ExtensionListEntry */ 996 bcpKey = LOCALE_ATTRIBUTE_KEY; 997 bcpValue = NULL; 998 } 999 } else if (isBcpUExt) { 1000 bcpKey = uloc_toUnicodeLocaleKey(key); 1001 if (bcpKey == NULL) { 1002 if (strict) { 1003 *status = U_ILLEGAL_ARGUMENT_ERROR; 1004 break; 1005 } 1006 continue; 1007 } 1008 1009 /* we've checked buf is null-terminated above */ 1010 bcpValue = uloc_toUnicodeLocaleType(key, buf); 1011 if (bcpValue == NULL) { 1012 if (strict) { 1013 *status = U_ILLEGAL_ARGUMENT_ERROR; 1014 break; 1015 } 1016 continue; 1017 } 1018 if (bcpValue == buf) { 1019 /* 1020 When uloc_toUnicodeLocaleType(key, buf) returns the 1021 input value as is, the value is well-formed, but has 1022 no known mapping. This implementation normalizes the 1023 the value to lower case 1024 */ 1025 int32_t bcpValueLen = static_cast<int32_t>(uprv_strlen(bcpValue)); 1026 if (bcpValueLen < extBufCapacity) { 1027 uprv_strcpy(pExtBuf, bcpValue); 1028 T_CString_toLowerCase(pExtBuf); 1029 1030 bcpValue = pExtBuf; 1031 1032 pExtBuf += (bcpValueLen + 1); 1033 extBufCapacity -= (bcpValueLen + 1); 1034 } else { 1035 if (strict) { 1036 *status = U_ILLEGAL_ARGUMENT_ERROR; 1037 break; 1038 } 1039 continue; 1040 } 1041 } 1042 } else { 1043 if (*key == PRIVATEUSE) { 1044 if (!_isPrivateuseValueSubtags(buf, len)) { 1045 if (strict) { 1046 *status = U_ILLEGAL_ARGUMENT_ERROR; 1047 break; 1048 } 1049 continue; 1050 } 1051 } else { 1052 if (!_isExtensionSingleton(key, keylen) || !_isExtensionSubtags(buf, len)) { 1053 if (strict) { 1054 *status = U_ILLEGAL_ARGUMENT_ERROR; 1055 break; 1056 } 1057 continue; 1058 } 1059 } 1060 bcpKey = key; 1061 if ((len + 1) < extBufCapacity) { 1062 uprv_memcpy(pExtBuf, buf, len); 1063 bcpValue = pExtBuf; 1064 1065 pExtBuf += len; 1066 1067 *pExtBuf = 0; 1068 pExtBuf++; 1069 1070 extBufCapacity -= (len + 1); 1071 } else { 1072 *status = U_ILLEGAL_ARGUMENT_ERROR; 1073 break; 1074 } 1075 } 1076 1077 /* create ExtensionListEntry */ 1078 ext = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 1079 if (ext == NULL) { 1080 *status = U_MEMORY_ALLOCATION_ERROR; 1081 break; 1082 } 1083 ext->key = bcpKey; 1084 ext->value = bcpValue; 1085 1086 if (!_addExtensionToList(&firstExt, ext, TRUE)) { 1087 uprv_free(ext); 1088 if (strict) { 1089 *status = U_ILLEGAL_ARGUMENT_ERROR; 1090 break; 1091 } 1092 } 1093 } 1094 1095 /* Special handling for POSIX variant - add the keywords for POSIX */ 1096 if (hadPosix) { 1097 /* create ExtensionListEntry for POSIX */ 1098 ext = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 1099 if (ext == NULL) { 1100 *status = U_MEMORY_ALLOCATION_ERROR; 1101 goto cleanup; 1102 } 1103 ext->key = POSIX_KEY; 1104 ext->value = POSIX_VALUE; 1105 1106 if (!_addExtensionToList(&firstExt, ext, TRUE)) { 1107 uprv_free(ext); 1108 } 1109 } 1110 1111 if (U_SUCCESS(*status) && (firstExt != NULL || firstAttr != NULL)) { 1112 UBool startLDMLExtension = FALSE; 1113 for (ext = firstExt; ext; ext = ext->next) { 1114 if (!startLDMLExtension && uprv_strlen(ext->key) > 1) { 1115 /* first LDML u singlton extension */ 1116 if (reslen < capacity) { 1117 *(appendAt + reslen) = SEP; 1118 } 1119 reslen++; 1120 if (reslen < capacity) { 1121 *(appendAt + reslen) = LDMLEXT; 1122 } 1123 reslen++; 1124 1125 startLDMLExtension = TRUE; 1126 } 1127 1128 /* write out the sorted BCP47 attributes, extensions and private use */ 1129 if (uprv_strcmp(ext->key, LOCALE_ATTRIBUTE_KEY) == 0) { 1130 /* write the value for the attributes */ 1131 for (attr = firstAttr; attr; attr = attr->next) { 1132 if (reslen < capacity) { 1133 *(appendAt + reslen) = SEP; 1134 } 1135 reslen++; 1136 len = (int32_t)uprv_strlen(attr->attribute); 1137 if (reslen < capacity) { 1138 uprv_memcpy(appendAt + reslen, attr->attribute, uprv_min(len, capacity - reslen)); 1139 } 1140 reslen += len; 1141 } 1142 } else { 1143 if (reslen < capacity) { 1144 *(appendAt + reslen) = SEP; 1145 } 1146 reslen++; 1147 len = (int32_t)uprv_strlen(ext->key); 1148 if (reslen < capacity) { 1149 uprv_memcpy(appendAt + reslen, ext->key, uprv_min(len, capacity - reslen)); 1150 } 1151 reslen += len; 1152 if (reslen < capacity) { 1153 *(appendAt + reslen) = SEP; 1154 } 1155 reslen++; 1156 len = (int32_t)uprv_strlen(ext->value); 1157 if (reslen < capacity) { 1158 uprv_memcpy(appendAt + reslen, ext->value, uprv_min(len, capacity - reslen)); 1159 } 1160 reslen += len; 1161 } 1162 } 1163 } 1164 cleanup: 1165 /* clean up */ 1166 ext = firstExt; 1167 while (ext != NULL) { 1168 ExtensionListEntry *tmpExt = ext->next; 1169 uprv_free(ext); 1170 ext = tmpExt; 1171 } 1172 1173 attr = firstAttr; 1174 while (attr != NULL) { 1175 AttributeListEntry *tmpAttr = attr->next; 1176 char *pValue = (char *)attr->attribute; 1177 uprv_free(pValue); 1178 uprv_free(attr); 1179 attr = tmpAttr; 1180 } 1181 1182 uenum_close(keywordEnum); 1183 1184 if (U_FAILURE(*status)) { 1185 return 0; 1186 } 1187 } 1188 1189 return u_terminateChars(appendAt, capacity, reslen, status); 1190 } 1191 1192 /** 1193 * Append keywords parsed from LDML extension value 1194 * e.g. "u-ca-gregory-co-trad" -> {calendar = gregorian} {collation = traditional} 1195 * Note: char* buf is used for storing keywords 1196 */ 1197 static void 1198 _appendLDMLExtensionAsKeywords(const char* ldmlext, ExtensionListEntry** appendTo, char* buf, int32_t bufSize, UBool *posixVariant, UErrorCode *status) { 1199 const char *pTag; /* beginning of current subtag */ 1200 const char *pKwds; /* beginning of key-type pairs */ 1201 UBool variantExists = *posixVariant; 1202 1203 ExtensionListEntry *kwdFirst = NULL; /* first LDML keyword */ 1204 ExtensionListEntry *kwd, *nextKwd; 1205 1206 AttributeListEntry *attrFirst = NULL; /* first attribute */ 1207 AttributeListEntry *attr, *nextAttr; 1208 1209 int32_t len; 1210 int32_t bufIdx = 0; 1211 1212 char attrBuf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; 1213 int32_t attrBufIdx = 0; 1214 1215 /* Reset the posixVariant value */ 1216 *posixVariant = FALSE; 1217 1218 pTag = ldmlext; 1219 pKwds = NULL; 1220 1221 /* Iterate through u extension attributes */ 1222 while (*pTag) { 1223 /* locate next separator char */ 1224 for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); 1225 1226 if (ultag_isUnicodeLocaleKey(pTag, len)) { 1227 pKwds = pTag; 1228 break; 1229 } 1230 1231 /* add this attribute to the list */ 1232 attr = (AttributeListEntry*)uprv_malloc(sizeof(AttributeListEntry)); 1233 if (attr == NULL) { 1234 *status = U_MEMORY_ALLOCATION_ERROR; 1235 goto cleanup; 1236 } 1237 1238 if (len < (int32_t)sizeof(attrBuf) - attrBufIdx) { 1239 uprv_memcpy(&attrBuf[attrBufIdx], pTag, len); 1240 attrBuf[attrBufIdx + len] = 0; 1241 attr->attribute = &attrBuf[attrBufIdx]; 1242 attrBufIdx += (len + 1); 1243 } else { 1244 *status = U_ILLEGAL_ARGUMENT_ERROR; 1245 goto cleanup; 1246 } 1247 1248 if (!_addAttributeToList(&attrFirst, attr)) { 1249 *status = U_ILLEGAL_ARGUMENT_ERROR; 1250 uprv_free(attr); 1251 goto cleanup; 1252 } 1253 1254 /* next tag */ 1255 pTag += len; 1256 if (*pTag) { 1257 /* next to the separator */ 1258 pTag++; 1259 } 1260 } 1261 1262 if (attrFirst) { 1263 /* emit attributes as an LDML keyword, e.g. attribute=attr1-attr2 */ 1264 1265 if (attrBufIdx > bufSize) { 1266 /* attrBufIdx == <total length of attribute subtag> + 1 */ 1267 *status = U_ILLEGAL_ARGUMENT_ERROR; 1268 goto cleanup; 1269 } 1270 1271 kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 1272 if (kwd == NULL) { 1273 *status = U_MEMORY_ALLOCATION_ERROR; 1274 goto cleanup; 1275 } 1276 1277 kwd->key = LOCALE_ATTRIBUTE_KEY; 1278 kwd->value = buf; 1279 1280 /* attribute subtags sorted in alphabetical order as type */ 1281 attr = attrFirst; 1282 while (attr != NULL) { 1283 nextAttr = attr->next; 1284 1285 /* buffer size check is done above */ 1286 if (attr != attrFirst) { 1287 *(buf + bufIdx) = SEP; 1288 bufIdx++; 1289 } 1290 1291 len = static_cast<int32_t>(uprv_strlen(attr->attribute)); 1292 uprv_memcpy(buf + bufIdx, attr->attribute, len); 1293 bufIdx += len; 1294 1295 attr = nextAttr; 1296 } 1297 *(buf + bufIdx) = 0; 1298 bufIdx++; 1299 1300 if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { 1301 *status = U_ILLEGAL_ARGUMENT_ERROR; 1302 uprv_free(kwd); 1303 goto cleanup; 1304 } 1305 1306 /* once keyword entry is created, delete the attribute list */ 1307 attr = attrFirst; 1308 while (attr != NULL) { 1309 nextAttr = attr->next; 1310 uprv_free(attr); 1311 attr = nextAttr; 1312 } 1313 attrFirst = NULL; 1314 } 1315 1316 if (pKwds) { 1317 const char *pBcpKey = NULL; /* u extenstion key subtag */ 1318 const char *pBcpType = NULL; /* beginning of u extension type subtag(s) */ 1319 int32_t bcpKeyLen = 0; 1320 int32_t bcpTypeLen = 0; 1321 UBool isDone = FALSE; 1322 1323 pTag = pKwds; 1324 /* BCP47 representation of LDML key/type pairs */ 1325 while (!isDone) { 1326 const char *pNextBcpKey = NULL; 1327 int32_t nextBcpKeyLen = 0; 1328 UBool emitKeyword = FALSE; 1329 1330 if (*pTag) { 1331 /* locate next separator char */ 1332 for (len = 0; *(pTag + len) && *(pTag + len) != SEP; len++); 1333 1334 if (ultag_isUnicodeLocaleKey(pTag, len)) { 1335 if (pBcpKey) { 1336 emitKeyword = TRUE; 1337 pNextBcpKey = pTag; 1338 nextBcpKeyLen = len; 1339 } else { 1340 pBcpKey = pTag; 1341 bcpKeyLen = len; 1342 } 1343 } else { 1344 U_ASSERT(pBcpKey != NULL); 1345 /* within LDML type subtags */ 1346 if (pBcpType) { 1347 bcpTypeLen += (len + 1); 1348 } else { 1349 pBcpType = pTag; 1350 bcpTypeLen = len; 1351 } 1352 } 1353 1354 /* next tag */ 1355 pTag += len; 1356 if (*pTag) { 1357 /* next to the separator */ 1358 pTag++; 1359 } 1360 } else { 1361 /* processing last one */ 1362 emitKeyword = TRUE; 1363 isDone = TRUE; 1364 } 1365 1366 if (emitKeyword) { 1367 const char *pKey = NULL; /* LDML key */ 1368 const char *pType = NULL; /* LDML type */ 1369 1370 char bcpKeyBuf[9]; /* BCP key length is always 2 for now */ 1371 1372 U_ASSERT(pBcpKey != NULL); 1373 1374 if (bcpKeyLen >= (int32_t)sizeof(bcpKeyBuf)) { 1375 /* the BCP key is invalid */ 1376 *status = U_ILLEGAL_ARGUMENT_ERROR; 1377 goto cleanup; 1378 } 1379 1380 uprv_strncpy(bcpKeyBuf, pBcpKey, bcpKeyLen); 1381 bcpKeyBuf[bcpKeyLen] = 0; 1382 1383 /* u extension key to LDML key */ 1384 pKey = uloc_toLegacyKey(bcpKeyBuf); 1385 if (pKey == NULL) { 1386 *status = U_ILLEGAL_ARGUMENT_ERROR; 1387 goto cleanup; 1388 } 1389 if (pKey == bcpKeyBuf) { 1390 /* 1391 The key returned by toLegacyKey points to the input buffer. 1392 We normalize the result key to lower case. 1393 */ 1394 T_CString_toLowerCase(bcpKeyBuf); 1395 if (bufSize - bufIdx - 1 >= bcpKeyLen) { 1396 uprv_memcpy(buf + bufIdx, bcpKeyBuf, bcpKeyLen); 1397 pKey = buf + bufIdx; 1398 bufIdx += bcpKeyLen; 1399 *(buf + bufIdx) = 0; 1400 bufIdx++; 1401 } else { 1402 *status = U_BUFFER_OVERFLOW_ERROR; 1403 goto cleanup; 1404 } 1405 } 1406 1407 if (pBcpType) { 1408 char bcpTypeBuf[128]; /* practically long enough even considering multiple subtag type */ 1409 if (bcpTypeLen >= (int32_t)sizeof(bcpTypeBuf)) { 1410 /* the BCP type is too long */ 1411 *status = U_ILLEGAL_ARGUMENT_ERROR; 1412 goto cleanup; 1413 } 1414 1415 uprv_strncpy(bcpTypeBuf, pBcpType, bcpTypeLen); 1416 bcpTypeBuf[bcpTypeLen] = 0; 1417 1418 /* BCP type to locale type */ 1419 pType = uloc_toLegacyType(pKey, bcpTypeBuf); 1420 if (pType == NULL) { 1421 *status = U_ILLEGAL_ARGUMENT_ERROR; 1422 goto cleanup; 1423 } 1424 if (pType == bcpTypeBuf) { 1425 /* 1426 The type returned by toLegacyType points to the input buffer. 1427 We normalize the result type to lower case. 1428 */ 1429 /* normalize to lower case */ 1430 T_CString_toLowerCase(bcpTypeBuf); 1431 if (bufSize - bufIdx - 1 >= bcpTypeLen) { 1432 uprv_memcpy(buf + bufIdx, bcpTypeBuf, bcpTypeLen); 1433 pType = buf + bufIdx; 1434 bufIdx += bcpTypeLen; 1435 *(buf + bufIdx) = 0; 1436 bufIdx++; 1437 } else { 1438 *status = U_BUFFER_OVERFLOW_ERROR; 1439 goto cleanup; 1440 } 1441 } 1442 } else { 1443 /* typeless - default type value is "yes" */ 1444 pType = LOCALE_TYPE_YES; 1445 } 1446 1447 /* Special handling for u-va-posix, since we want to treat this as a variant, 1448 not as a keyword */ 1449 if (!variantExists && !uprv_strcmp(pKey, POSIX_KEY) && !uprv_strcmp(pType, POSIX_VALUE) ) { 1450 *posixVariant = TRUE; 1451 } else { 1452 /* create an ExtensionListEntry for this keyword */ 1453 kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 1454 if (kwd == NULL) { 1455 *status = U_MEMORY_ALLOCATION_ERROR; 1456 goto cleanup; 1457 } 1458 1459 kwd->key = pKey; 1460 kwd->value = pType; 1461 1462 if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { 1463 *status = U_ILLEGAL_ARGUMENT_ERROR; 1464 uprv_free(kwd); 1465 goto cleanup; 1466 } 1467 } 1468 1469 pBcpKey = pNextBcpKey; 1470 bcpKeyLen = pNextBcpKey != NULL ? nextBcpKeyLen : 0; 1471 pBcpType = NULL; 1472 bcpTypeLen = 0; 1473 } 1474 } 1475 } 1476 1477 kwd = kwdFirst; 1478 while (kwd != NULL) { 1479 nextKwd = kwd->next; 1480 _addExtensionToList(appendTo, kwd, FALSE); 1481 kwd = nextKwd; 1482 } 1483 1484 return; 1485 1486 cleanup: 1487 attr = attrFirst; 1488 while (attr != NULL) { 1489 nextAttr = attr->next; 1490 uprv_free(attr); 1491 attr = nextAttr; 1492 } 1493 1494 kwd = kwdFirst; 1495 while (kwd != NULL) { 1496 nextKwd = kwd->next; 1497 uprv_free(kwd); 1498 kwd = nextKwd; 1499 } 1500 } 1501 1502 1503 static int32_t 1504 _appendKeywords(ULanguageTag* langtag, char* appendAt, int32_t capacity, UErrorCode* status) { 1505 int32_t reslen = 0; 1506 int32_t i, n; 1507 int32_t len; 1508 ExtensionListEntry *kwdFirst = NULL; 1509 ExtensionListEntry *kwd; 1510 const char *key, *type; 1511 char *kwdBuf = NULL; 1512 int32_t kwdBufLength = capacity; 1513 UBool posixVariant = FALSE; 1514 1515 if (U_FAILURE(*status)) { 1516 return 0; 1517 } 1518 1519 kwdBuf = (char*)uprv_malloc(kwdBufLength); 1520 if (kwdBuf == NULL) { 1521 *status = U_MEMORY_ALLOCATION_ERROR; 1522 return 0; 1523 } 1524 1525 /* Determine if variants already exists */ 1526 if (ultag_getVariantsSize(langtag)) { 1527 posixVariant = TRUE; 1528 } 1529 1530 n = ultag_getExtensionsSize(langtag); 1531 1532 /* resolve locale keywords and reordering keys */ 1533 for (i = 0; i < n; i++) { 1534 key = ultag_getExtensionKey(langtag, i); 1535 type = ultag_getExtensionValue(langtag, i); 1536 if (*key == LDMLEXT) { 1537 _appendLDMLExtensionAsKeywords(type, &kwdFirst, kwdBuf, kwdBufLength, &posixVariant, status); 1538 if (U_FAILURE(*status)) { 1539 break; 1540 } 1541 } else { 1542 kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 1543 if (kwd == NULL) { 1544 *status = U_MEMORY_ALLOCATION_ERROR; 1545 break; 1546 } 1547 kwd->key = key; 1548 kwd->value = type; 1549 if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { 1550 uprv_free(kwd); 1551 *status = U_ILLEGAL_ARGUMENT_ERROR; 1552 break; 1553 } 1554 } 1555 } 1556 1557 if (U_SUCCESS(*status)) { 1558 type = ultag_getPrivateUse(langtag); 1559 if ((int32_t)uprv_strlen(type) > 0) { 1560 /* add private use as a keyword */ 1561 kwd = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 1562 if (kwd == NULL) { 1563 *status = U_MEMORY_ALLOCATION_ERROR; 1564 } else { 1565 kwd->key = PRIVATEUSE_KEY; 1566 kwd->value = type; 1567 if (!_addExtensionToList(&kwdFirst, kwd, FALSE)) { 1568 uprv_free(kwd); 1569 *status = U_ILLEGAL_ARGUMENT_ERROR; 1570 } 1571 } 1572 } 1573 } 1574 1575 /* If a POSIX variant was in the extensions, write it out before writing the keywords. */ 1576 1577 if (U_SUCCESS(*status) && posixVariant) { 1578 len = (int32_t) uprv_strlen(_POSIX); 1579 if (reslen < capacity) { 1580 uprv_memcpy(appendAt + reslen, _POSIX, uprv_min(len, capacity - reslen)); 1581 } 1582 reslen += len; 1583 } 1584 1585 if (U_SUCCESS(*status) && kwdFirst != NULL) { 1586 /* write out the sorted keywords */ 1587 UBool firstValue = TRUE; 1588 kwd = kwdFirst; 1589 do { 1590 if (reslen < capacity) { 1591 if (firstValue) { 1592 /* '@' */ 1593 *(appendAt + reslen) = LOCALE_EXT_SEP; 1594 firstValue = FALSE; 1595 } else { 1596 /* ';' */ 1597 *(appendAt + reslen) = LOCALE_KEYWORD_SEP; 1598 } 1599 } 1600 reslen++; 1601 1602 /* key */ 1603 len = (int32_t)uprv_strlen(kwd->key); 1604 if (reslen < capacity) { 1605 uprv_memcpy(appendAt + reslen, kwd->key, uprv_min(len, capacity - reslen)); 1606 } 1607 reslen += len; 1608 1609 /* '=' */ 1610 if (reslen < capacity) { 1611 *(appendAt + reslen) = LOCALE_KEY_TYPE_SEP; 1612 } 1613 reslen++; 1614 1615 /* type */ 1616 len = (int32_t)uprv_strlen(kwd->value); 1617 if (reslen < capacity) { 1618 uprv_memcpy(appendAt + reslen, kwd->value, uprv_min(len, capacity - reslen)); 1619 } 1620 reslen += len; 1621 1622 kwd = kwd->next; 1623 } while (kwd); 1624 } 1625 1626 /* clean up */ 1627 kwd = kwdFirst; 1628 while (kwd != NULL) { 1629 ExtensionListEntry *tmpKwd = kwd->next; 1630 uprv_free(kwd); 1631 kwd = tmpKwd; 1632 } 1633 1634 uprv_free(kwdBuf); 1635 1636 if (U_FAILURE(*status)) { 1637 return 0; 1638 } 1639 1640 return u_terminateChars(appendAt, capacity, reslen, status); 1641 } 1642 1643 static int32_t 1644 _appendPrivateuseToLanguageTag(const char* localeID, char* appendAt, int32_t capacity, UBool strict, UBool hadPosix, UErrorCode* status) { 1645 (void)hadPosix; 1646 char buf[ULOC_FULLNAME_CAPACITY]; 1647 char tmpAppend[ULOC_FULLNAME_CAPACITY]; 1648 UErrorCode tmpStatus = U_ZERO_ERROR; 1649 int32_t len, i; 1650 int32_t reslen = 0; 1651 1652 if (U_FAILURE(*status)) { 1653 return 0; 1654 } 1655 1656 len = uloc_getVariant(localeID, buf, sizeof(buf), &tmpStatus); 1657 if (U_FAILURE(tmpStatus) || tmpStatus == U_STRING_NOT_TERMINATED_WARNING) { 1658 if (strict) { 1659 *status = U_ILLEGAL_ARGUMENT_ERROR; 1660 } 1661 return 0; 1662 } 1663 1664 if (len > 0) { 1665 char *p, *pPriv; 1666 UBool bNext = TRUE; 1667 UBool firstValue = TRUE; 1668 UBool writeValue; 1669 1670 pPriv = NULL; 1671 p = buf; 1672 while (bNext) { 1673 writeValue = FALSE; 1674 if (*p == SEP || *p == LOCALE_SEP || *p == 0) { 1675 if (*p == 0) { 1676 bNext = FALSE; 1677 } else { 1678 *p = 0; /* terminate */ 1679 } 1680 if (pPriv != NULL) { 1681 /* Private use in the canonical format is lowercase in BCP47 */ 1682 for (i = 0; *(pPriv + i) != 0; i++) { 1683 *(pPriv + i) = uprv_tolower(*(pPriv + i)); 1684 } 1685 1686 /* validate */ 1687 if (_isPrivateuseValueSubtag(pPriv, -1)) { 1688 if (firstValue) { 1689 if (!_isVariantSubtag(pPriv, -1)) { 1690 writeValue = TRUE; 1691 } 1692 } else { 1693 writeValue = TRUE; 1694 } 1695 } else if (strict) { 1696 *status = U_ILLEGAL_ARGUMENT_ERROR; 1697 break; 1698 } else { 1699 break; 1700 } 1701 1702 if (writeValue) { 1703 if (reslen < capacity) { 1704 tmpAppend[reslen++] = SEP; 1705 } 1706 1707 if (firstValue) { 1708 if (reslen < capacity) { 1709 tmpAppend[reslen++] = *PRIVATEUSE_KEY; 1710 } 1711 1712 if (reslen < capacity) { 1713 tmpAppend[reslen++] = SEP; 1714 } 1715 1716 len = (int32_t)uprv_strlen(PRIVUSE_VARIANT_PREFIX); 1717 if (reslen < capacity) { 1718 uprv_memcpy(tmpAppend + reslen, PRIVUSE_VARIANT_PREFIX, uprv_min(len, capacity - reslen)); 1719 } 1720 reslen += len; 1721 1722 if (reslen < capacity) { 1723 tmpAppend[reslen++] = SEP; 1724 } 1725 1726 firstValue = FALSE; 1727 } 1728 1729 len = (int32_t)uprv_strlen(pPriv); 1730 if (reslen < capacity) { 1731 uprv_memcpy(tmpAppend + reslen, pPriv, uprv_min(len, capacity - reslen)); 1732 } 1733 reslen += len; 1734 } 1735 } 1736 /* reset private use starting position */ 1737 pPriv = NULL; 1738 } else if (pPriv == NULL) { 1739 pPriv = p; 1740 } 1741 p++; 1742 } 1743 1744 if (U_FAILURE(*status)) { 1745 return 0; 1746 } 1747 } 1748 1749 if (U_SUCCESS(*status)) { 1750 len = reslen; 1751 if (reslen < capacity) { 1752 uprv_memcpy(appendAt, tmpAppend, uprv_min(len, capacity - reslen)); 1753 } 1754 } 1755 1756 u_terminateChars(appendAt, capacity, reslen, status); 1757 1758 return reslen; 1759 } 1760 1761 /* 1762 * ------------------------------------------------- 1763 * 1764 * ultag_ functions 1765 * 1766 * ------------------------------------------------- 1767 */ 1768 1769 /* Bit flags used by the parser */ 1770 #define LANG 0x0001 1771 #define EXTL 0x0002 1772 #define SCRT 0x0004 1773 #define REGN 0x0008 1774 #define VART 0x0010 1775 #define EXTS 0x0020 1776 #define EXTV 0x0040 1777 #define PRIV 0x0080 1778 1779 /** 1780 * Ticket #12705 - Visual Studio 2015 Update 3 contains a new code optimizer which has problems optimizing 1781 * this function. (See https://blogs.msdn.microsoft.com/vcblog/2016/05/04/new-code-optimizer/ ) 1782 * As a workaround, we will turn off optimization just for this function on VS2015 Update 3 and above. 1783 */ 1784 #if (defined(_MSC_VER) && (_MSC_VER >= 1900) && defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190024210)) 1785 #pragma optimize( "", off ) 1786 #endif 1787 1788 static ULanguageTag* 1789 ultag_parse(const char* tag, int32_t tagLen, int32_t* parsedLen, UErrorCode* status) { 1790 ULanguageTag *t; 1791 char *tagBuf; 1792 int16_t next; 1793 char *pSubtag, *pNext, *pLastGoodPosition; 1794 int32_t subtagLen; 1795 int32_t extlangIdx; 1796 ExtensionListEntry *pExtension; 1797 char *pExtValueSubtag, *pExtValueSubtagEnd; 1798 int32_t i; 1799 UBool privateuseVar = FALSE; 1800 int32_t grandfatheredLen = 0; 1801 1802 if (parsedLen != NULL) { 1803 *parsedLen = 0; 1804 } 1805 1806 if (U_FAILURE(*status)) { 1807 return NULL; 1808 } 1809 1810 if (tagLen < 0) { 1811 tagLen = (int32_t)uprv_strlen(tag); 1812 } 1813 1814 /* copy the entire string */ 1815 tagBuf = (char*)uprv_malloc(tagLen + 1); 1816 if (tagBuf == NULL) { 1817 *status = U_MEMORY_ALLOCATION_ERROR; 1818 return NULL; 1819 } 1820 uprv_memcpy(tagBuf, tag, tagLen); 1821 *(tagBuf + tagLen) = 0; 1822 1823 /* create a ULanguageTag */ 1824 t = (ULanguageTag*)uprv_malloc(sizeof(ULanguageTag)); 1825 if (t == NULL) { 1826 uprv_free(tagBuf); 1827 *status = U_MEMORY_ALLOCATION_ERROR; 1828 return NULL; 1829 } 1830 _initializeULanguageTag(t); 1831 t->buf = tagBuf; 1832 1833 if (tagLen < MINLEN) { 1834 /* the input tag is too short - return empty ULanguageTag */ 1835 return t; 1836 } 1837 1838 /* check if the tag is grandfathered */ 1839 for (i = 0; GRANDFATHERED[i] != NULL; i += 2) { 1840 if (uprv_stricmp(GRANDFATHERED[i], tagBuf) == 0) { 1841 int32_t newTagLength; 1842 1843 grandfatheredLen = tagLen; /* back up for output parsedLen */ 1844 newTagLength = static_cast<int32_t>(uprv_strlen(GRANDFATHERED[i+1])); 1845 if (tagLen < newTagLength) { 1846 uprv_free(tagBuf); 1847 tagBuf = (char*)uprv_malloc(newTagLength + 1); 1848 if (tagBuf == NULL) { 1849 *status = U_MEMORY_ALLOCATION_ERROR; 1850 ultag_close(t); 1851 return NULL; 1852 } 1853 t->buf = tagBuf; 1854 tagLen = newTagLength; 1855 } 1856 uprv_strcpy(t->buf, GRANDFATHERED[i + 1]); 1857 break; 1858 } 1859 } 1860 1861 /* 1862 * langtag = language 1863 * ["-" script] 1864 * ["-" region] 1865 * *("-" variant) 1866 * *("-" extension) 1867 * ["-" privateuse] 1868 */ 1869 1870 next = LANG | PRIV; 1871 pNext = pLastGoodPosition = tagBuf; 1872 extlangIdx = 0; 1873 pExtension = NULL; 1874 pExtValueSubtag = NULL; 1875 pExtValueSubtagEnd = NULL; 1876 1877 while (pNext) { 1878 char *pSep; 1879 1880 pSubtag = pNext; 1881 1882 /* locate next separator char */ 1883 pSep = pSubtag; 1884 while (*pSep) { 1885 if (*pSep == SEP) { 1886 break; 1887 } 1888 pSep++; 1889 } 1890 if (*pSep == 0) { 1891 /* last subtag */ 1892 pNext = NULL; 1893 } else { 1894 pNext = pSep + 1; 1895 } 1896 subtagLen = (int32_t)(pSep - pSubtag); 1897 1898 if (next & LANG) { 1899 if (_isLanguageSubtag(pSubtag, subtagLen)) { 1900 *pSep = 0; /* terminate */ 1901 t->language = T_CString_toLowerCase(pSubtag); 1902 1903 pLastGoodPosition = pSep; 1904 next = EXTL | SCRT | REGN | VART | EXTS | PRIV; 1905 continue; 1906 } 1907 } 1908 if (next & EXTL) { 1909 if (_isExtlangSubtag(pSubtag, subtagLen)) { 1910 *pSep = 0; 1911 t->extlang[extlangIdx++] = T_CString_toLowerCase(pSubtag); 1912 1913 pLastGoodPosition = pSep; 1914 if (extlangIdx < 3) { 1915 next = EXTL | SCRT | REGN | VART | EXTS | PRIV; 1916 } else { 1917 next = SCRT | REGN | VART | EXTS | PRIV; 1918 } 1919 continue; 1920 } 1921 } 1922 if (next & SCRT) { 1923 if (_isScriptSubtag(pSubtag, subtagLen)) { 1924 char *p = pSubtag; 1925 1926 *pSep = 0; 1927 1928 /* to title case */ 1929 *p = uprv_toupper(*p); 1930 p++; 1931 for (; *p; p++) { 1932 *p = uprv_tolower(*p); 1933 } 1934 1935 t->script = pSubtag; 1936 1937 pLastGoodPosition = pSep; 1938 next = REGN | VART | EXTS | PRIV; 1939 continue; 1940 } 1941 } 1942 if (next & REGN) { 1943 if (_isRegionSubtag(pSubtag, subtagLen)) { 1944 *pSep = 0; 1945 t->region = T_CString_toUpperCase(pSubtag); 1946 1947 pLastGoodPosition = pSep; 1948 next = VART | EXTS | PRIV; 1949 continue; 1950 } 1951 } 1952 if (next & VART) { 1953 if (_isVariantSubtag(pSubtag, subtagLen) || 1954 (privateuseVar && _isPrivateuseVariantSubtag(pSubtag, subtagLen))) { 1955 VariantListEntry *var; 1956 UBool isAdded; 1957 1958 var = (VariantListEntry*)uprv_malloc(sizeof(VariantListEntry)); 1959 if (var == NULL) { 1960 *status = U_MEMORY_ALLOCATION_ERROR; 1961 goto error; 1962 } 1963 *pSep = 0; 1964 var->variant = T_CString_toUpperCase(pSubtag); 1965 isAdded = _addVariantToList(&(t->variants), var); 1966 if (!isAdded) { 1967 /* duplicated variant entry */ 1968 uprv_free(var); 1969 break; 1970 } 1971 pLastGoodPosition = pSep; 1972 next = VART | EXTS | PRIV; 1973 continue; 1974 } 1975 } 1976 if (next & EXTS) { 1977 if (_isExtensionSingleton(pSubtag, subtagLen)) { 1978 if (pExtension != NULL) { 1979 if (pExtValueSubtag == NULL || pExtValueSubtagEnd == NULL) { 1980 /* the previous extension is incomplete */ 1981 uprv_free(pExtension); 1982 pExtension = NULL; 1983 break; 1984 } 1985 1986 /* terminate the previous extension value */ 1987 *pExtValueSubtagEnd = 0; 1988 pExtension->value = T_CString_toLowerCase(pExtValueSubtag); 1989 1990 /* insert the extension to the list */ 1991 if (_addExtensionToList(&(t->extensions), pExtension, FALSE)) { 1992 pLastGoodPosition = pExtValueSubtagEnd; 1993 } else { 1994 /* stop parsing here */ 1995 uprv_free(pExtension); 1996 pExtension = NULL; 1997 break; 1998 } 1999 } 2000 2001 /* create a new extension */ 2002 pExtension = (ExtensionListEntry*)uprv_malloc(sizeof(ExtensionListEntry)); 2003 if (pExtension == NULL) { 2004 *status = U_MEMORY_ALLOCATION_ERROR; 2005 goto error; 2006 } 2007 *pSep = 0; 2008 pExtension->key = T_CString_toLowerCase(pSubtag); 2009 pExtension->value = NULL; /* will be set later */ 2010 2011 /* 2012 * reset the start and the end location of extension value 2013 * subtags for this extension 2014 */ 2015 pExtValueSubtag = NULL; 2016 pExtValueSubtagEnd = NULL; 2017 2018 next = EXTV; 2019 continue; 2020 } 2021 } 2022 if (next & EXTV) { 2023 if (_isExtensionSubtag(pSubtag, subtagLen)) { 2024 if (pExtValueSubtag == NULL) { 2025 /* if the start postion of this extension's value is not yet, 2026 this one is the first value subtag */ 2027 pExtValueSubtag = pSubtag; 2028 } 2029 2030 /* Mark the end of this subtag */ 2031 pExtValueSubtagEnd = pSep; 2032 next = EXTS | EXTV | PRIV; 2033 2034 continue; 2035 } 2036 } 2037 if (next & PRIV) { 2038 if (uprv_tolower(*pSubtag) == PRIVATEUSE) { 2039 char *pPrivuseVal; 2040 2041 if (pExtension != NULL) { 2042 /* Process the last extension */ 2043 if (pExtValueSubtag == NULL || pExtValueSubtagEnd == NULL) { 2044 /* the previous extension is incomplete */ 2045 uprv_free(pExtension); 2046 pExtension = NULL; 2047 break; 2048 } else { 2049 /* terminate the previous extension value */ 2050 *pExtValueSubtagEnd = 0; 2051 pExtension->value = T_CString_toLowerCase(pExtValueSubtag); 2052 2053 /* insert the extension to the list */ 2054 if (_addExtensionToList(&(t->extensions), pExtension, FALSE)) { 2055 pLastGoodPosition = pExtValueSubtagEnd; 2056 pExtension = NULL; 2057 } else { 2058 /* stop parsing here */ 2059 uprv_free(pExtension); 2060 pExtension = NULL; 2061 break; 2062 } 2063 } 2064 } 2065 2066 /* The rest of part will be private use value subtags */ 2067 if (pNext == NULL) { 2068 /* empty private use subtag */ 2069 break; 2070 } 2071 /* back up the private use value start position */ 2072 pPrivuseVal = pNext; 2073 2074 /* validate private use value subtags */ 2075 while (pNext) { 2076 pSubtag = pNext; 2077 pSep = pSubtag; 2078 while (*pSep) { 2079 if (*pSep == SEP) { 2080 break; 2081 } 2082 pSep++; 2083 } 2084 if (*pSep == 0) { 2085 /* last subtag */ 2086 pNext = NULL; 2087 } else { 2088 pNext = pSep + 1; 2089 } 2090 subtagLen = (int32_t)(pSep - pSubtag); 2091 2092 if (uprv_strncmp(pSubtag, PRIVUSE_VARIANT_PREFIX, uprv_strlen(PRIVUSE_VARIANT_PREFIX)) == 0) { 2093 *pSep = 0; 2094 next = VART; 2095 privateuseVar = TRUE; 2096 break; 2097 } else if (_isPrivateuseValueSubtag(pSubtag, subtagLen)) { 2098 pLastGoodPosition = pSep; 2099 } else { 2100 break; 2101 } 2102 } 2103 2104 if (next == VART) { 2105 continue; 2106 } 2107 2108 if (pLastGoodPosition - pPrivuseVal > 0) { 2109 *pLastGoodPosition = 0; 2110 t->privateuse = T_CString_toLowerCase(pPrivuseVal); 2111 } 2112 /* No more subtags, exiting the parse loop */ 2113 break; 2114 } 2115 break; 2116 } 2117 2118 /* If we fell through here, it means this subtag is illegal - quit parsing */ 2119 break; 2120 } 2121 2122 if (pExtension != NULL) { 2123 /* Process the last extension */ 2124 if (pExtValueSubtag == NULL || pExtValueSubtagEnd == NULL) { 2125 /* the previous extension is incomplete */ 2126 uprv_free(pExtension); 2127 } else { 2128 /* terminate the previous extension value */ 2129 *pExtValueSubtagEnd = 0; 2130 pExtension->value = T_CString_toLowerCase(pExtValueSubtag); 2131 /* insert the extension to the list */ 2132 if (_addExtensionToList(&(t->extensions), pExtension, FALSE)) { 2133 pLastGoodPosition = pExtValueSubtagEnd; 2134 } else { 2135 uprv_free(pExtension); 2136 } 2137 } 2138 } 2139 2140 if (parsedLen != NULL) { 2141 *parsedLen = (grandfatheredLen > 0) ? grandfatheredLen : (int32_t)(pLastGoodPosition - t->buf); 2142 } 2143 2144 return t; 2145 2146 error: 2147 ultag_close(t); 2148 return NULL; 2149 } 2150 2151 /** 2152 * Ticket #12705 - Turn optimization back on. 2153 */ 2154 #if (defined(_MSC_VER) && (_MSC_VER >= 1900) && defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190024210)) 2155 #pragma optimize( "", on ) 2156 #endif 2157 2158 static void 2159 ultag_close(ULanguageTag* langtag) { 2160 2161 if (langtag == NULL) { 2162 return; 2163 } 2164 2165 uprv_free(langtag->buf); 2166 2167 if (langtag->variants) { 2168 VariantListEntry *curVar = langtag->variants; 2169 while (curVar) { 2170 VariantListEntry *nextVar = curVar->next; 2171 uprv_free(curVar); 2172 curVar = nextVar; 2173 } 2174 } 2175 2176 if (langtag->extensions) { 2177 ExtensionListEntry *curExt = langtag->extensions; 2178 while (curExt) { 2179 ExtensionListEntry *nextExt = curExt->next; 2180 uprv_free(curExt); 2181 curExt = nextExt; 2182 } 2183 } 2184 2185 uprv_free(langtag); 2186 } 2187 2188 static const char* 2189 ultag_getLanguage(const ULanguageTag* langtag) { 2190 return langtag->language; 2191 } 2192 2193 #if 0 2194 static const char* 2195 ultag_getJDKLanguage(const ULanguageTag* langtag) { 2196 int32_t i; 2197 for (i = 0; DEPRECATEDLANGS[i] != NULL; i += 2) { 2198 if (uprv_compareInvCharsAsAscii(DEPRECATEDLANGS[i], langtag->language) == 0) { 2199 return DEPRECATEDLANGS[i + 1]; 2200 } 2201 } 2202 return langtag->language; 2203 } 2204 #endif 2205 2206 static const char* 2207 ultag_getExtlang(const ULanguageTag* langtag, int32_t idx) { 2208 if (idx >= 0 && idx < MAXEXTLANG) { 2209 return langtag->extlang[idx]; 2210 } 2211 return NULL; 2212 } 2213 2214 static int32_t 2215 ultag_getExtlangSize(const ULanguageTag* langtag) { 2216 int32_t size = 0; 2217 int32_t i; 2218 for (i = 0; i < MAXEXTLANG; i++) { 2219 if (langtag->extlang[i]) { 2220 size++; 2221 } 2222 } 2223 return size; 2224 } 2225 2226 static const char* 2227 ultag_getScript(const ULanguageTag* langtag) { 2228 return langtag->script; 2229 } 2230 2231 static const char* 2232 ultag_getRegion(const ULanguageTag* langtag) { 2233 return langtag->region; 2234 } 2235 2236 static const char* 2237 ultag_getVariant(const ULanguageTag* langtag, int32_t idx) { 2238 const char *var = NULL; 2239 VariantListEntry *cur = langtag->variants; 2240 int32_t i = 0; 2241 while (cur) { 2242 if (i == idx) { 2243 var = cur->variant; 2244 break; 2245 } 2246 cur = cur->next; 2247 i++; 2248 } 2249 return var; 2250 } 2251 2252 static int32_t 2253 ultag_getVariantsSize(const ULanguageTag* langtag) { 2254 int32_t size = 0; 2255 VariantListEntry *cur = langtag->variants; 2256 while (TRUE) { 2257 if (cur == NULL) { 2258 break; 2259 } 2260 size++; 2261 cur = cur->next; 2262 } 2263 return size; 2264 } 2265 2266 static const char* 2267 ultag_getExtensionKey(const ULanguageTag* langtag, int32_t idx) { 2268 const char *key = NULL; 2269 ExtensionListEntry *cur = langtag->extensions; 2270 int32_t i = 0; 2271 while (cur) { 2272 if (i == idx) { 2273 key = cur->key; 2274 break; 2275 } 2276 cur = cur->next; 2277 i++; 2278 } 2279 return key; 2280 } 2281 2282 static const char* 2283 ultag_getExtensionValue(const ULanguageTag* langtag, int32_t idx) { 2284 const char *val = NULL; 2285 ExtensionListEntry *cur = langtag->extensions; 2286 int32_t i = 0; 2287 while (cur) { 2288 if (i == idx) { 2289 val = cur->value; 2290 break; 2291 } 2292 cur = cur->next; 2293 i++; 2294 } 2295 return val; 2296 } 2297 2298 static int32_t 2299 ultag_getExtensionsSize(const ULanguageTag* langtag) { 2300 int32_t size = 0; 2301 ExtensionListEntry *cur = langtag->extensions; 2302 while (TRUE) { 2303 if (cur == NULL) { 2304 break; 2305 } 2306 size++; 2307 cur = cur->next; 2308 } 2309 return size; 2310 } 2311 2312 static const char* 2313 ultag_getPrivateUse(const ULanguageTag* langtag) { 2314 return langtag->privateuse; 2315 } 2316 2317 #if 0 2318 static const char* 2319 ultag_getGrandfathered(const ULanguageTag* langtag) { 2320 return langtag->grandfathered; 2321 } 2322 #endif 2323 2324 2325 /* 2326 * ------------------------------------------------- 2327 * 2328 * Locale/BCP47 conversion APIs, exposed as uloc_* 2329 * 2330 * ------------------------------------------------- 2331 */ 2332 U_CAPI int32_t U_EXPORT2 2333 uloc_toLanguageTag(const char* localeID, 2334 char* langtag, 2335 int32_t langtagCapacity, 2336 UBool strict, 2337 UErrorCode* status) { 2338 /* char canonical[ULOC_FULLNAME_CAPACITY]; */ /* See #6822 */ 2339 char canonical[256]; 2340 int32_t reslen = 0; 2341 UErrorCode tmpStatus = U_ZERO_ERROR; 2342 UBool hadPosix = FALSE; 2343 const char* pKeywordStart; 2344 2345 /* Note: uloc_canonicalize returns "en_US_POSIX" for input locale ID "". See #6835 */ 2346 canonical[0] = 0; 2347 if (uprv_strlen(localeID) > 0) { 2348 uloc_canonicalize(localeID, canonical, sizeof(canonical), &tmpStatus); 2349 if (tmpStatus != U_ZERO_ERROR) { 2350 *status = U_ILLEGAL_ARGUMENT_ERROR; 2351 return 0; 2352 } 2353 } 2354 2355 /* For handling special case - private use only tag */ 2356 pKeywordStart = locale_getKeywordsStart(canonical); 2357 if (pKeywordStart == canonical) { 2358 UEnumeration *kwdEnum; 2359 int kwdCnt = 0; 2360 UBool done = FALSE; 2361 2362 kwdEnum = uloc_openKeywords((const char*)canonical, &tmpStatus); 2363 if (kwdEnum != NULL) { 2364 kwdCnt = uenum_count(kwdEnum, &tmpStatus); 2365 if (kwdCnt == 1) { 2366 const char *key; 2367 int32_t len = 0; 2368 2369 key = uenum_next(kwdEnum, &len, &tmpStatus); 2370 if (len == 1 && *key == PRIVATEUSE) { 2371 char buf[ULOC_KEYWORD_AND_VALUES_CAPACITY]; 2372 buf[0] = PRIVATEUSE; 2373 buf[1] = SEP; 2374 len = uloc_getKeywordValue(localeID, key, &buf[2], sizeof(buf) - 2, &tmpStatus); 2375 if (U_SUCCESS(tmpStatus)) { 2376 if (_isPrivateuseValueSubtags(&buf[2], len)) { 2377 /* return private use only tag */ 2378 reslen = len + 2; 2379 uprv_memcpy(langtag, buf, uprv_min(reslen, langtagCapacity)); 2380 u_terminateChars(langtag, langtagCapacity, reslen, status); 2381 done = TRUE; 2382 } else if (strict) { 2383 *status = U_ILLEGAL_ARGUMENT_ERROR; 2384 done = TRUE; 2385 } 2386 /* if not strict mode, then "und" will be returned */ 2387 } else { 2388 *status = U_ILLEGAL_ARGUMENT_ERROR; 2389 done = TRUE; 2390 } 2391 } 2392 } 2393 uenum_close(kwdEnum); 2394 if (done) { 2395 return reslen; 2396 } 2397 } 2398 } 2399 2400 reslen += _appendLanguageToLanguageTag(canonical, langtag, langtagCapacity, strict, status); 2401 reslen += _appendScriptToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, status); 2402 reslen += _appendRegionToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, status); 2403 reslen += _appendVariantsToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, &hadPosix, status); 2404 reslen += _appendKeywordsToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, hadPosix, status); 2405 reslen += _appendPrivateuseToLanguageTag(canonical, langtag + reslen, langtagCapacity - reslen, strict, hadPosix, status); 2406 2407 return reslen; 2408 } 2409 2410 2411 U_CAPI int32_t U_EXPORT2 2412 uloc_forLanguageTag(const char* langtag, 2413 char* localeID, 2414 int32_t localeIDCapacity, 2415 int32_t* parsedLength, 2416 UErrorCode* status) { 2417 ULanguageTag *lt; 2418 int32_t reslen = 0; 2419 const char *subtag, *p; 2420 int32_t len; 2421 int32_t i, n; 2422 UBool noRegion = TRUE; 2423 2424 lt = ultag_parse(langtag, -1, parsedLength, status); 2425 if (U_FAILURE(*status)) { 2426 return 0; 2427 } 2428 2429 /* language */ 2430 subtag = ultag_getExtlangSize(lt) > 0 ? ultag_getExtlang(lt, 0) : ultag_getLanguage(lt); 2431 if (uprv_compareInvCharsAsAscii(subtag, LANG_UND) != 0) { 2432 len = (int32_t)uprv_strlen(subtag); 2433 if (len > 0) { 2434 if (reslen < localeIDCapacity) { 2435 uprv_memcpy(localeID, subtag, uprv_min(len, localeIDCapacity - reslen)); 2436 } 2437 reslen += len; 2438 } 2439 } 2440 2441 /* script */ 2442 subtag = ultag_getScript(lt); 2443 len = (int32_t)uprv_strlen(subtag); 2444 if (len > 0) { 2445 if (reslen < localeIDCapacity) { 2446 *(localeID + reslen) = LOCALE_SEP; 2447 } 2448 reslen++; 2449 2450 /* write out the script in title case */ 2451 p = subtag; 2452 while (*p) { 2453 if (reslen < localeIDCapacity) { 2454 if (p == subtag) { 2455 *(localeID + reslen) = uprv_toupper(*p); 2456 } else { 2457 *(localeID + reslen) = *p; 2458 } 2459 } 2460 reslen++; 2461 p++; 2462 } 2463 } 2464 2465 /* region */ 2466 subtag = ultag_getRegion(lt); 2467 len = (int32_t)uprv_strlen(subtag); 2468 if (len > 0) { 2469 if (reslen < localeIDCapacity) { 2470 *(localeID + reslen) = LOCALE_SEP; 2471 } 2472 reslen++; 2473 /* write out the retion in upper case */ 2474 p = subtag; 2475 while (*p) { 2476 if (reslen < localeIDCapacity) { 2477 *(localeID + reslen) = uprv_toupper(*p); 2478 } 2479 reslen++; 2480 p++; 2481 } 2482 noRegion = FALSE; 2483 } 2484 2485 /* variants */ 2486 n = ultag_getVariantsSize(lt); 2487 if (n > 0) { 2488 if (noRegion) { 2489 if (reslen < localeIDCapacity) { 2490 *(localeID + reslen) = LOCALE_SEP; 2491 } 2492 reslen++; 2493 } 2494 2495 for (i = 0; i < n; i++) { 2496 subtag = ultag_getVariant(lt, i); 2497 if (reslen < localeIDCapacity) { 2498 *(localeID + reslen) = LOCALE_SEP; 2499 } 2500 reslen++; 2501 /* write out the variant in upper case */ 2502 p = subtag; 2503 while (*p) { 2504 if (reslen < localeIDCapacity) { 2505 *(localeID + reslen) = uprv_toupper(*p); 2506 } 2507 reslen++; 2508 p++; 2509 } 2510 } 2511 } 2512 2513 /* keywords */ 2514 n = ultag_getExtensionsSize(lt); 2515 subtag = ultag_getPrivateUse(lt); 2516 if (n > 0 || uprv_strlen(subtag) > 0) { 2517 if (reslen == 0 && n > 0) { 2518 /* need a language */ 2519 if (reslen < localeIDCapacity) { 2520 uprv_memcpy(localeID + reslen, LANG_UND, uprv_min(LANG_UND_LEN, localeIDCapacity - reslen)); 2521 } 2522 reslen += LANG_UND_LEN; 2523 } 2524 len = _appendKeywords(lt, localeID + reslen, localeIDCapacity - reslen, status); 2525 reslen += len; 2526 } 2527 2528 ultag_close(lt); 2529 return u_terminateChars(localeID, localeIDCapacity, reslen, status); 2530 } 2531 2532 2533
