src/third_party/icu/source/common/uloc_tag.c

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