icuSources/common/loclikely.cpp

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 1997-2012, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  loclikely.cpp
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2010feb25
  14 *   created by: Markus W. Scherer
  15 *
  16 *   Code for likely and minimized locale subtags, separated out from other .cpp files
  17 *   that then do not depend on resource bundle code and likely-subtags data.
  18 */
  19
  20 #include "unicode/utypes.h"
  21 #include "unicode/putil.h"
  22 #include "unicode/uloc.h"
  23 #include "unicode/ures.h"
  24 #include "cmemory.h"
  25 #include "cstring.h"
  26 #include "ulocimp.h"
  27 #include "ustr_imp.h"
  28
  29 /**
  30  * This function looks for the localeID in the likelySubtags resource.
  31  *
  32  * @param localeID The tag to find.
  33  * @param buffer A buffer to hold the matching entry
  34  * @param bufferLength The length of the output buffer
  35  * @return A pointer to "buffer" if found, or a null pointer if not.
  36  */
  37 static const char*  U_CALLCONV
  38 findLikelySubtags(const char* localeID,
  39                   char* buffer,
  40                   int32_t bufferLength,
  41                   UErrorCode* err) {
  42     const char* result = NULL;
  43
  44     if (!U_FAILURE(*err)) {
  45         int32_t resLen = 0;
  46         const UChar* s = NULL;
  47         UErrorCode tmpErr = U_ZERO_ERROR;
  48         UResourceBundle* subtags = ures_openDirect(NULL, "likelySubtags", &tmpErr);
  49         if (U_SUCCESS(tmpErr)) {
  50             s = ures_getStringByKey(subtags, localeID, &resLen, &tmpErr);
  51
  52             if (U_FAILURE(tmpErr)) {
  53                 /*
  54                  * If a resource is missing, it's not really an error, it's
  55                  * just that we don't have any data for that particular locale ID.
  56                  */
  57                 if (tmpErr != U_MISSING_RESOURCE_ERROR) {
  58                     *err = tmpErr;
  59                 }
  60             }
  61             else if (resLen >= bufferLength) {
  62                 /* The buffer should never overflow. */
  63                 *err = U_INTERNAL_PROGRAM_ERROR;
  64             }
  65             else {
  66                 u_UCharsToChars(s, buffer, resLen + 1);
  67                 result = buffer;
  68             }
  69
  70             ures_close(subtags);
  71         } else {
  72             *err = tmpErr;
  73         }
  74     }
  75
  76     return result;
  77 }
  78
  79 /**
  80  * Append a tag to a buffer, adding the separator if necessary.  The buffer
  81  * must be large enough to contain the resulting tag plus any separator
  82  * necessary. The tag must not be a zero-length string.
  83  *
  84  * @param tag The tag to add.
  85  * @param tagLength The length of the tag.
  86  * @param buffer The output buffer.
  87  * @param bufferLength The length of the output buffer.  This is an input/ouput parameter.
  88  **/
  89 static void U_CALLCONV
  90 appendTag(
  91     const char* tag,
  92     int32_t tagLength,
  93     char* buffer,
  94     int32_t* bufferLength) {
  95
  96     if (*bufferLength > 0) {
  97         buffer[*bufferLength] = '_';
  98         ++(*bufferLength);
  99     }
 100
 101     uprv_memmove(
 102         &buffer[*bufferLength],
 103         tag,
 104         tagLength);
 105
 106     *bufferLength += tagLength;
 107 }
 108
 109 /**
 110  * These are the canonical strings for unknown languages, scripts and regions.
 111  **/
 112 static const char* const unknownLanguage = "und";
 113 static const char* const unknownScript = "Zzzz";
 114 static const char* const unknownRegion = "ZZ";
 115
 116 /**
 117  * Create a tag string from the supplied parameters.  The lang, script and region
 118  * parameters may be NULL pointers. If they are, their corresponding length parameters
 119  * must be less than or equal to 0.
 120  *
 121  * If any of the language, script or region parameters are empty, and the alternateTags
 122  * parameter is not NULL, it will be parsed for potential language, script and region tags
 123  * to be used when constructing the new tag.  If the alternateTags parameter is NULL, or
 124  * it contains no language tag, the default tag for the unknown language is used.
 125  *
 126  * If the length of the new string exceeds the capacity of the output buffer,
 127  * the function copies as many bytes to the output buffer as it can, and returns
 128  * the error U_BUFFER_OVERFLOW_ERROR.
 129  *
 130  * If an illegal argument is provided, the function returns the error
 131  * U_ILLEGAL_ARGUMENT_ERROR.
 132  *
 133  * Note that this function can return the warning U_STRING_NOT_TERMINATED_WARNING if
 134  * the tag string fits in the output buffer, but the null terminator doesn't.
 135  *
 136  * @param lang The language tag to use.
 137  * @param langLength The length of the language tag.
 138  * @param script The script tag to use.
 139  * @param scriptLength The length of the script tag.
 140  * @param region The region tag to use.
 141  * @param regionLength The length of the region tag.
 142  * @param trailing Any trailing data to append to the new tag.
 143  * @param trailingLength The length of the trailing data.
 144  * @param alternateTags A string containing any alternate tags.
 145  * @param tag The output buffer.
 146  * @param tagCapacity The capacity of the output buffer.
 147  * @param err A pointer to a UErrorCode for error reporting.
 148  * @return The length of the tag string, which may be greater than tagCapacity, or -1 on error.
 149  **/
 150 static int32_t U_CALLCONV
 151 createTagStringWithAlternates(
 152     const char* lang,
 153     int32_t langLength,
 154     const char* script,
 155     int32_t scriptLength,
 156     const char* region,
 157     int32_t regionLength,
 158     const char* trailing,
 159     int32_t trailingLength,
 160     const char* alternateTags,
 161     char* tag,
 162     int32_t tagCapacity,
 163     UErrorCode* err) {
 164
 165     if (U_FAILURE(*err)) {
 166         goto error;
 167     }
 168     else if (tag == NULL ||
 169              tagCapacity <= 0 ||
 170              langLength >= ULOC_LANG_CAPACITY ||
 171              scriptLength >= ULOC_SCRIPT_CAPACITY ||
 172              regionLength >= ULOC_COUNTRY_CAPACITY) {
 173         goto error;
 174     }
 175     else {
 176         /**
 177          * ULOC_FULLNAME_CAPACITY will provide enough capacity
 178          * that we can build a string that contains the language,
 179          * script and region code without worrying about overrunning
 180          * the user-supplied buffer.
 181          **/
 182         char tagBuffer[ULOC_FULLNAME_CAPACITY];
 183         int32_t tagLength = 0;
 184         int32_t capacityRemaining = tagCapacity;
 185         UBool regionAppended = FALSE;
 186
 187         if (langLength > 0) {
 188             appendTag(
 189                 lang,
 190                 langLength,
 191                 tagBuffer,
 192                 &tagLength);
 193         }
 194         else if (alternateTags == NULL) {
 195             /*
 196              * Append the value for an unknown language, if
 197              * we found no language.
 198              */
 199             appendTag(
 200                 unknownLanguage,
 201                 (int32_t)uprv_strlen(unknownLanguage),
 202                 tagBuffer,
 203                 &tagLength);
 204         }
 205         else {
 206             /*
 207              * Parse the alternateTags string for the language.
 208              */
 209             char alternateLang[ULOC_LANG_CAPACITY];
 210             int32_t alternateLangLength = sizeof(alternateLang);
 211
 212             alternateLangLength =
 213                 uloc_getLanguage(
 214                     alternateTags,
 215                     alternateLang,
 216                     alternateLangLength,
 217                     err);
 218             if(U_FAILURE(*err) ||
 219                 alternateLangLength >= ULOC_LANG_CAPACITY) {
 220                 goto error;
 221             }
 222             else if (alternateLangLength == 0) {
 223                 /*
 224                  * Append the value for an unknown language, if
 225                  * we found no language.
 226                  */
 227                 appendTag(
 228                     unknownLanguage,
 229                     (int32_t)uprv_strlen(unknownLanguage),
 230                     tagBuffer,
 231                     &tagLength);
 232             }
 233             else {
 234                 appendTag(
 235                     alternateLang,
 236                     alternateLangLength,
 237                     tagBuffer,
 238                     &tagLength);
 239             }
 240         }
 241
 242         if (scriptLength > 0) {
 243             appendTag(
 244                 script,
 245                 scriptLength,
 246                 tagBuffer,
 247                 &tagLength);
 248         }
 249         else if (alternateTags != NULL) {
 250             /*
 251              * Parse the alternateTags string for the script.
 252              */
 253             char alternateScript[ULOC_SCRIPT_CAPACITY];
 254
 255             const int32_t alternateScriptLength =
 256                 uloc_getScript(
 257                     alternateTags,
 258                     alternateScript,
 259                     sizeof(alternateScript),
 260                     err);
 261
 262             if (U_FAILURE(*err) ||
 263                 alternateScriptLength >= ULOC_SCRIPT_CAPACITY) {
 264                 goto error;
 265             }
 266             else if (alternateScriptLength > 0) {
 267                 appendTag(
 268                     alternateScript,
 269                     alternateScriptLength,
 270                     tagBuffer,
 271                     &tagLength);
 272             }
 273         }
 274
 275         if (regionLength > 0) {
 276             appendTag(
 277                 region,
 278                 regionLength,
 279                 tagBuffer,
 280                 &tagLength);
 281
 282             regionAppended = TRUE;
 283         }
 284         else if (alternateTags != NULL) {
 285             /*
 286              * Parse the alternateTags string for the region.
 287              */
 288             char alternateRegion[ULOC_COUNTRY_CAPACITY];
 289
 290             const int32_t alternateRegionLength =
 291                 uloc_getCountry(
 292                     alternateTags,
 293                     alternateRegion,
 294                     sizeof(alternateRegion),
 295                     err);
 296             if (U_FAILURE(*err) ||
 297                 alternateRegionLength >= ULOC_COUNTRY_CAPACITY) {
 298                 goto error;
 299             }
 300             else if (alternateRegionLength > 0) {
 301                 appendTag(
 302                     alternateRegion,
 303                     alternateRegionLength,
 304                     tagBuffer,
 305                     &tagLength);
 306
 307                 regionAppended = TRUE;
 308             }
 309         }
 310
 311         {
 312             const int32_t toCopy =
 313                 tagLength >= tagCapacity ? tagCapacity : tagLength;
 314
 315             /**
 316              * Copy the partial tag from our internal buffer to the supplied
 317              * target.
 318              **/
 319             uprv_memcpy(
 320                 tag,
 321                 tagBuffer,
 322                 toCopy);
 323
 324             capacityRemaining -= toCopy;
 325         }
 326
 327         if (trailingLength > 0) {
 328             if (*trailing != '@' && capacityRemaining > 0) {
 329                 tag[tagLength++] = '_';
 330                 --capacityRemaining;
 331                 if (capacityRemaining > 0 && !regionAppended) {
 332                     /* extra separator is required */
 333                     tag[tagLength++] = '_';
 334                     --capacityRemaining;
 335                 }
 336             }
 337
 338             if (capacityRemaining > 0) {
 339                 /*
 340                  * Copy the trailing data into the supplied buffer.  Use uprv_memmove, since we
 341                  * don't know if the user-supplied buffers overlap.
 342                  */
 343                 const int32_t toCopy =
 344                     trailingLength >= capacityRemaining ? capacityRemaining : trailingLength;
 345
 346                 uprv_memmove(
 347                     &tag[tagLength],
 348                     trailing,
 349                     toCopy);
 350             }
 351         }
 352
 353         tagLength += trailingLength;
 354
 355         return u_terminateChars(
 356                     tag,
 357                     tagCapacity,
 358                     tagLength,
 359                     err);
 360     }
 361
 362 error:
 363
 364     /**
 365      * An overflow indicates the locale ID passed in
 366      * is ill-formed.  If we got here, and there was
 367      * no previous error, it's an implicit overflow.
 368      **/
 369     if (*err ==  U_BUFFER_OVERFLOW_ERROR ||
 370         U_SUCCESS(*err)) {
 371         *err = U_ILLEGAL_ARGUMENT_ERROR;
 372     }
 373
 374     return -1;
 375 }
 376
 377 /**
 378  * Create a tag string from the supplied parameters.  The lang, script and region
 379  * parameters may be NULL pointers. If they are, their corresponding length parameters
 380  * must be less than or equal to 0.  If the lang parameter is an empty string, the
 381  * default value for an unknown language is written to the output buffer.
 382  *
 383  * If the length of the new string exceeds the capacity of the output buffer,
 384  * the function copies as many bytes to the output buffer as it can, and returns
 385  * the error U_BUFFER_OVERFLOW_ERROR.
 386  *
 387  * If an illegal argument is provided, the function returns the error
 388  * U_ILLEGAL_ARGUMENT_ERROR.
 389  *
 390  * @param lang The language tag to use.
 391  * @param langLength The length of the language tag.
 392  * @param script The script tag to use.
 393  * @param scriptLength The length of the script tag.
 394  * @param region The region tag to use.
 395  * @param regionLength The length of the region tag.
 396  * @param trailing Any trailing data to append to the new tag.
 397  * @param trailingLength The length of the trailing data.
 398  * @param tag The output buffer.
 399  * @param tagCapacity The capacity of the output buffer.
 400  * @param err A pointer to a UErrorCode for error reporting.
 401  * @return The length of the tag string, which may be greater than tagCapacity.
 402  **/
 403 static int32_t U_CALLCONV
 404 createTagString(
 405     const char* lang,
 406     int32_t langLength,
 407     const char* script,
 408     int32_t scriptLength,
 409     const char* region,
 410     int32_t regionLength,
 411     const char* trailing,
 412     int32_t trailingLength,
 413     char* tag,
 414     int32_t tagCapacity,
 415     UErrorCode* err)
 416 {
 417     return createTagStringWithAlternates(
 418                 lang,
 419                 langLength,
 420                 script,
 421                 scriptLength,
 422                 region,
 423                 regionLength,
 424                 trailing,
 425                 trailingLength,
 426                 NULL,
 427                 tag,
 428                 tagCapacity,
 429                 err);
 430 }
 431
 432 /**
 433  * Parse the language, script, and region subtags from a tag string, and copy the
 434  * results into the corresponding output parameters. The buffers are null-terminated,
 435  * unless overflow occurs.
 436  *
 437  * The langLength, scriptLength, and regionLength parameters are input/output
 438  * parameters, and must contain the capacity of their corresponding buffers on
 439  * input.  On output, they will contain the actual length of the buffers, not
 440  * including the null terminator.
 441  *
 442  * If the length of any of the output subtags exceeds the capacity of the corresponding
 443  * buffer, the function copies as many bytes to the output buffer as it can, and returns
 444  * the error U_BUFFER_OVERFLOW_ERROR.  It will not parse any more subtags once overflow
 445  * occurs.
 446  *
 447  * If an illegal argument is provided, the function returns the error
 448  * U_ILLEGAL_ARGUMENT_ERROR.
 449  *
 450  * @param localeID The locale ID to parse.
 451  * @param lang The language tag buffer.
 452  * @param langLength The length of the language tag.
 453  * @param script The script tag buffer.
 454  * @param scriptLength The length of the script tag.
 455  * @param region The region tag buffer.
 456  * @param regionLength The length of the region tag.
 457  * @param err A pointer to a UErrorCode for error reporting.
 458  * @return The number of chars of the localeID parameter consumed.
 459  **/
 460 static int32_t U_CALLCONV
 461 parseTagString(
 462     const char* localeID,
 463     char* lang,
 464     int32_t* langLength,
 465     char* script,
 466     int32_t* scriptLength,
 467     char* region,
 468     int32_t* regionLength,
 469     UErrorCode* err)
 470 {
 471     const char* position = localeID;
 472     int32_t subtagLength = 0;
 473
 474     if(U_FAILURE(*err) ||
 475        localeID == NULL ||
 476        lang == NULL ||
 477        langLength == NULL ||
 478        script == NULL ||
 479        scriptLength == NULL ||
 480        region == NULL ||
 481        regionLength == NULL) {
 482         goto error;
 483     }
 484
 485     subtagLength = ulocimp_getLanguage(position, lang, *langLength, &position);
 486     u_terminateChars(lang, *langLength, subtagLength, err);
 487
 488     /*
 489      * Note that we explicit consider U_STRING_NOT_TERMINATED_WARNING
 490      * to be an error, because it indicates the user-supplied tag is
 491      * not well-formed.
 492      */
 493     if(U_FAILURE(*err)) {
 494         goto error;
 495     }
 496
 497     *langLength = subtagLength;
 498
 499     /*
 500      * If no language was present, use the value of unknownLanguage
 501      * instead.  Otherwise, move past any separator.
 502      */
 503     if (*langLength == 0) {
 504         uprv_strcpy(
 505             lang,
 506             unknownLanguage);
 507         *langLength = (int32_t)uprv_strlen(lang);
 508     }
 509     else if (_isIDSeparator(*position)) {
 510         ++position;
 511     }
 512
 513     subtagLength = ulocimp_getScript(position, script, *scriptLength, &position);
 514     u_terminateChars(script, *scriptLength, subtagLength, err);
 515
 516     if(U_FAILURE(*err)) {
 517         goto error;
 518     }
 519
 520     *scriptLength = subtagLength;
 521
 522     if (*scriptLength > 0) {
 523         if (uprv_strnicmp(script, unknownScript, *scriptLength) == 0) {
 524             /**
 525              * If the script part is the "unknown" script, then don't return it.
 526              **/
 527             *scriptLength = 0;
 528         }
 529
 530         /*
 531          * Move past any separator.
 532          */
 533         if (_isIDSeparator(*position)) {
 534             ++position;
 535         }
 536     }
 537
 538     subtagLength = ulocimp_getCountry(position, region, *regionLength, &position);
 539     u_terminateChars(region, *regionLength, subtagLength, err);
 540
 541     if(U_FAILURE(*err)) {
 542         goto error;
 543     }
 544
 545     *regionLength = subtagLength;
 546
 547     if (*regionLength > 0) {
 548         if (uprv_strnicmp(region, unknownRegion, *regionLength) == 0) {
 549             /**
 550              * If the region part is the "unknown" region, then don't return it.
 551              **/
 552             *regionLength = 0;
 553         }
 554     } else if (*position != 0 && *position != '@') {
 555         /* back up over consumed trailing separator */
 556         --position;
 557     }
 558
 559 exit:
 560
 561     return (int32_t)(position - localeID);
 562
 563 error:
 564
 565     /**
 566      * If we get here, we have no explicit error, it's the result of an
 567      * illegal argument.
 568      **/
 569     if (!U_FAILURE(*err)) {
 570         *err = U_ILLEGAL_ARGUMENT_ERROR;
 571     }
 572
 573     goto exit;
 574 }
 575
 576 static int32_t U_CALLCONV
 577 createLikelySubtagsString(
 578     const char* lang,
 579     int32_t langLength,
 580     const char* script,
 581     int32_t scriptLength,
 582     const char* region,
 583     int32_t regionLength,
 584     const char* variants,
 585     int32_t variantsLength,
 586     char* tag,
 587     int32_t tagCapacity,
 588     UErrorCode* err)
 589 {
 590     /**
 591      * ULOC_FULLNAME_CAPACITY will provide enough capacity
 592      * that we can build a string that contains the language,
 593      * script and region code without worrying about overrunning
 594      * the user-supplied buffer.
 595      **/
 596     char tagBuffer[ULOC_FULLNAME_CAPACITY];
 597     char likelySubtagsBuffer[ULOC_FULLNAME_CAPACITY];
 598
 599     if(U_FAILURE(*err)) {
 600         goto error;
 601     }
 602
 603     /**
 604      * Try the language with the script and region first.
 605      **/
 606     if (scriptLength > 0 && regionLength > 0) {
 607
 608         const char* likelySubtags = NULL;
 609
 610         createTagString(
 611             lang,
 612             langLength,
 613             script,
 614             scriptLength,
 615             region,
 616             regionLength,
 617             NULL,
 618             0,
 619             tagBuffer,
 620             sizeof(tagBuffer),
 621             err);
 622         if(U_FAILURE(*err)) {
 623             goto error;
 624         }
 625
 626         likelySubtags =
 627             findLikelySubtags(
 628                 tagBuffer,
 629                 likelySubtagsBuffer,
 630                 sizeof(likelySubtagsBuffer),
 631                 err);
 632         if(U_FAILURE(*err)) {
 633             goto error;
 634         }
 635
 636         if (likelySubtags != NULL) {
 637             /* Always use the language tag from the
 638                maximal string, since it may be more
 639                specific than the one provided. */
 640             return createTagStringWithAlternates(
 641                         NULL,
 642                         0,
 643                         NULL,
 644                         0,
 645                         NULL,
 646                         0,
 647                         variants,
 648                         variantsLength,
 649                         likelySubtags,
 650                         tag,
 651                         tagCapacity,
 652                         err);
 653         }
 654     }
 655
 656     /**
 657      * Try the language with just the script.
 658      **/
 659     if (scriptLength > 0) {
 660
 661         const char* likelySubtags = NULL;
 662
 663         createTagString(
 664             lang,
 665             langLength,
 666             script,
 667             scriptLength,
 668             NULL,
 669             0,
 670             NULL,
 671             0,
 672             tagBuffer,
 673             sizeof(tagBuffer),
 674             err);
 675         if(U_FAILURE(*err)) {
 676             goto error;
 677         }
 678
 679         likelySubtags =
 680             findLikelySubtags(
 681                 tagBuffer,
 682                 likelySubtagsBuffer,
 683                 sizeof(likelySubtagsBuffer),
 684                 err);
 685         if(U_FAILURE(*err)) {
 686             goto error;
 687         }
 688
 689         if (likelySubtags != NULL) {
 690             /* Always use the language tag from the
 691                maximal string, since it may be more
 692                specific than the one provided. */
 693             return createTagStringWithAlternates(
 694                         NULL,
 695                         0,
 696                         NULL,
 697                         0,
 698                         region,
 699                         regionLength,
 700                         variants,
 701                         variantsLength,
 702                         likelySubtags,
 703                         tag,
 704                         tagCapacity,
 705                         err);
 706         }
 707     }
 708
 709     /**
 710      * Try the language with just the region.
 711      **/
 712     if (regionLength > 0) {
 713
 714         const char* likelySubtags = NULL;
 715
 716         createTagString(
 717             lang,
 718             langLength,
 719             NULL,
 720             0,
 721             region,
 722             regionLength,
 723             NULL,
 724             0,
 725             tagBuffer,
 726             sizeof(tagBuffer),
 727             err);
 728         if(U_FAILURE(*err)) {
 729             goto error;
 730         }
 731
 732         likelySubtags =
 733             findLikelySubtags(
 734                 tagBuffer,
 735                 likelySubtagsBuffer,
 736                 sizeof(likelySubtagsBuffer),
 737                 err);
 738         if(U_FAILURE(*err)) {
 739             goto error;
 740         }
 741
 742         if (likelySubtags != NULL) {
 743             /* Always use the language tag from the
 744                maximal string, since it may be more
 745                specific than the one provided. */
 746             return createTagStringWithAlternates(
 747                         NULL,
 748                         0,
 749                         script,
 750                         scriptLength,
 751                         NULL,
 752                         0,
 753                         variants,
 754                         variantsLength,
 755                         likelySubtags,
 756                         tag,
 757                         tagCapacity,
 758                         err);
 759         }
 760     }
 761
 762     /**
 763      * Finally, try just the language.
 764      **/
 765     {
 766         const char* likelySubtags = NULL;
 767
 768         createTagString(
 769             lang,
 770             langLength,
 771             NULL,
 772             0,
 773             NULL,
 774             0,
 775             NULL,
 776             0,
 777             tagBuffer,
 778             sizeof(tagBuffer),
 779             err);
 780         if(U_FAILURE(*err)) {
 781             goto error;
 782         }
 783
 784         likelySubtags =
 785             findLikelySubtags(
 786                 tagBuffer,
 787                 likelySubtagsBuffer,
 788                 sizeof(likelySubtagsBuffer),
 789                 err);
 790         if(U_FAILURE(*err)) {
 791             goto error;
 792         }
 793
 794         if (likelySubtags != NULL) {
 795             /* Always use the language tag from the
 796                maximal string, since it may be more
 797                specific than the one provided. */
 798             return createTagStringWithAlternates(
 799                         NULL,
 800                         0,
 801                         script,
 802                         scriptLength,
 803                         region,
 804                         regionLength,
 805                         variants,
 806                         variantsLength,
 807                         likelySubtags,
 808                         tag,
 809                         tagCapacity,
 810                         err);
 811         }
 812     }
 813
 814     return u_terminateChars(
 815                 tag,
 816                 tagCapacity,
 817                 0,
 818                 err);
 819
 820 error:
 821
 822     if (!U_FAILURE(*err)) {
 823         *err = U_ILLEGAL_ARGUMENT_ERROR;
 824     }
 825
 826     return -1;
 827 }
 828
 829 #define CHECK_TRAILING_VARIANT_SIZE(trailing, trailingLength) \
 830     {   int32_t count = 0; \
 831         int32_t i; \
 832         for (i = 0; i < trailingLength; i++) { \
 833             if (trailing[i] == '-' || trailing[i] == '_') { \
 834                 count = 0; \
 835                 if (count > 8) { \
 836                     goto error; \
 837                 } \
 838             } else if (trailing[i] == '@') { \
 839                 break; \
 840             } else if (count > 8) { \
 841                 goto error; \
 842             } else { \
 843                 count++; \
 844             } \
 845         } \
 846     }
 847
 848 static int32_t
 849 _uloc_addLikelySubtags(const char*    localeID,
 850          char* maximizedLocaleID,
 851          int32_t maximizedLocaleIDCapacity,
 852          UErrorCode* err)
 853 {
 854     char lang[ULOC_LANG_CAPACITY];
 855     int32_t langLength = sizeof(lang);
 856     char script[ULOC_SCRIPT_CAPACITY];
 857     int32_t scriptLength = sizeof(script);
 858     char region[ULOC_COUNTRY_CAPACITY];
 859     int32_t regionLength = sizeof(region);
 860     const char* trailing = "";
 861     int32_t trailingLength = 0;
 862     int32_t trailingIndex = 0;
 863     int32_t resultLength = 0;
 864
 865     if(U_FAILURE(*err)) {
 866         goto error;
 867     }
 868     else if (localeID == NULL ||
 869              maximizedLocaleID == NULL ||
 870              maximizedLocaleIDCapacity <= 0) {
 871         goto error;
 872     }
 873
 874     trailingIndex = parseTagString(
 875         localeID,
 876         lang,
 877         &langLength,
 878         script,
 879         &scriptLength,
 880         region,
 881         &regionLength,
 882         err);
 883     if(U_FAILURE(*err)) {
 884         /* Overflow indicates an illegal argument error */
 885         if (*err == U_BUFFER_OVERFLOW_ERROR) {
 886             *err = U_ILLEGAL_ARGUMENT_ERROR;
 887         }
 888
 889         goto error;
 890     }
 891
 892     /* Find the length of the trailing portion. */
 893     while (_isIDSeparator(localeID[trailingIndex])) {
 894         trailingIndex++;
 895     }
 896     trailing = &localeID[trailingIndex];
 897     trailingLength = (int32_t)uprv_strlen(trailing);
 898
 899     CHECK_TRAILING_VARIANT_SIZE(trailing, trailingLength);
 900
 901     resultLength =
 902         createLikelySubtagsString(
 903             lang,
 904             langLength,
 905             script,
 906             scriptLength,
 907             region,
 908             regionLength,
 909             trailing,
 910             trailingLength,
 911             maximizedLocaleID,
 912             maximizedLocaleIDCapacity,
 913             err);
 914
 915     if (resultLength == 0) {
 916         const int32_t localIDLength = (int32_t)uprv_strlen(localeID);
 917
 918         /*
 919          * If we get here, we need to return localeID.
 920          */
 921         uprv_memcpy(
 922             maximizedLocaleID,
 923             localeID,
 924             localIDLength <= maximizedLocaleIDCapacity ?
 925                 localIDLength : maximizedLocaleIDCapacity);
 926
 927         resultLength =
 928             u_terminateChars(
 929                 maximizedLocaleID,
 930                 maximizedLocaleIDCapacity,
 931                 localIDLength,
 932                 err);
 933     }
 934
 935     return resultLength;
 936
 937 error:
 938
 939     if (!U_FAILURE(*err)) {
 940         *err = U_ILLEGAL_ARGUMENT_ERROR;
 941     }
 942
 943     return -1;
 944 }
 945
 946 static int32_t
 947 _uloc_minimizeSubtags(const char*    localeID,
 948          char* minimizedLocaleID,
 949          int32_t minimizedLocaleIDCapacity,
 950          UErrorCode* err)
 951 {
 952     /**
 953      * ULOC_FULLNAME_CAPACITY will provide enough capacity
 954      * that we can build a string that contains the language,
 955      * script and region code without worrying about overrunning
 956      * the user-supplied buffer.
 957      **/
 958     char maximizedTagBuffer[ULOC_FULLNAME_CAPACITY];
 959     int32_t maximizedTagBufferLength = sizeof(maximizedTagBuffer);
 960
 961     char lang[ULOC_LANG_CAPACITY];
 962     int32_t langLength = sizeof(lang);
 963     char script[ULOC_SCRIPT_CAPACITY];
 964     int32_t scriptLength = sizeof(script);
 965     char region[ULOC_COUNTRY_CAPACITY];
 966     int32_t regionLength = sizeof(region);
 967     const char* trailing = "";
 968     int32_t trailingLength = 0;
 969     int32_t trailingIndex = 0;
 970
 971     if(U_FAILURE(*err)) {
 972         goto error;
 973     }
 974     else if (localeID == NULL ||
 975              minimizedLocaleID == NULL ||
 976              minimizedLocaleIDCapacity <= 0) {
 977         goto error;
 978     }
 979
 980     trailingIndex =
 981         parseTagString(
 982             localeID,
 983             lang,
 984             &langLength,
 985             script,
 986             &scriptLength,
 987             region,
 988             &regionLength,
 989             err);
 990     if(U_FAILURE(*err)) {
 991
 992         /* Overflow indicates an illegal argument error */
 993         if (*err == U_BUFFER_OVERFLOW_ERROR) {
 994             *err = U_ILLEGAL_ARGUMENT_ERROR;
 995         }
 996
 997         goto error;
 998     }
 999
1000     /* Find the spot where the variants or the keywords begin, if any. */
1001     while (_isIDSeparator(localeID[trailingIndex])) {
1002         trailingIndex++;
1003     }
1004     trailing = &localeID[trailingIndex];
1005     trailingLength = (int32_t)uprv_strlen(trailing);
1006
1007     CHECK_TRAILING_VARIANT_SIZE(trailing, trailingLength);
1008
1009     createTagString(
1010         lang,
1011         langLength,
1012         script,
1013         scriptLength,
1014         region,
1015         regionLength,
1016         NULL,
1017         0,
1018         maximizedTagBuffer,
1019         maximizedTagBufferLength,
1020         err);
1021     if(U_FAILURE(*err)) {
1022         goto error;
1023     }
1024
1025     /**
1026      * First, we need to first get the maximization
1027      * from AddLikelySubtags.
1028      **/
1029     maximizedTagBufferLength =
1030         uloc_addLikelySubtags(
1031             maximizedTagBuffer,
1032             maximizedTagBuffer,
1033             maximizedTagBufferLength,
1034             err);
1035
1036     if(U_FAILURE(*err)) {
1037         goto error;
1038     }
1039
1040     /**
1041      * Start first with just the language.
1042      **/
1043     {
1044         char tagBuffer[ULOC_FULLNAME_CAPACITY];
1045
1046         const int32_t tagBufferLength =
1047             createLikelySubtagsString(
1048                 lang,
1049                 langLength,
1050                 NULL,
1051                 0,
1052                 NULL,
1053                 0,
1054                 NULL,
1055                 0,
1056                 tagBuffer,
1057                 sizeof(tagBuffer),
1058                 err);
1059
1060         if(U_FAILURE(*err)) {
1061             goto error;
1062         }
1063         else if (uprv_strnicmp(
1064                     maximizedTagBuffer,
1065                     tagBuffer,
1066                     tagBufferLength) == 0) {
1067
1068             return createTagString(
1069                         lang,
1070                         langLength,
1071                         NULL,
1072                         0,
1073                         NULL,
1074                         0,
1075                         trailing,
1076                         trailingLength,
1077                         minimizedLocaleID,
1078                         minimizedLocaleIDCapacity,
1079                         err);
1080         }
1081     }
1082
1083     /**
1084      * Next, try the language and region.
1085      **/
1086     if (regionLength > 0) {
1087
1088         char tagBuffer[ULOC_FULLNAME_CAPACITY];
1089
1090         const int32_t tagBufferLength =
1091             createLikelySubtagsString(
1092                 lang,
1093                 langLength,
1094                 NULL,
1095                 0,
1096                 region,
1097                 regionLength,
1098                 NULL,
1099                 0,
1100                 tagBuffer,
1101                 sizeof(tagBuffer),
1102                 err);
1103
1104         if(U_FAILURE(*err)) {
1105             goto error;
1106         }
1107         else if (uprv_strnicmp(
1108                     maximizedTagBuffer,
1109                     tagBuffer,
1110                     tagBufferLength) == 0) {
1111
1112             return createTagString(
1113                         lang,
1114                         langLength,
1115                         NULL,
1116                         0,
1117                         region,
1118                         regionLength,
1119                         trailing,
1120                         trailingLength,
1121                         minimizedLocaleID,
1122                         minimizedLocaleIDCapacity,
1123                         err);
1124         }
1125     }
1126
1127     /**
1128      * Finally, try the language and script.  This is our last chance,
1129      * since trying with all three subtags would only yield the
1130      * maximal version that we already have.
1131      **/
1132     if (scriptLength > 0 && regionLength > 0) {
1133         char tagBuffer[ULOC_FULLNAME_CAPACITY];
1134
1135         const int32_t tagBufferLength =
1136             createLikelySubtagsString(
1137                 lang,
1138                 langLength,
1139                 script,
1140                 scriptLength,
1141                 NULL,
1142                 0,
1143                 NULL,
1144                 0,
1145                 tagBuffer,
1146                 sizeof(tagBuffer),
1147                 err);
1148
1149         if(U_FAILURE(*err)) {
1150             goto error;
1151         }
1152         else if (uprv_strnicmp(
1153                     maximizedTagBuffer,
1154                     tagBuffer,
1155                     tagBufferLength) == 0) {
1156
1157             return createTagString(
1158                         lang,
1159                         langLength,
1160                         script,
1161                         scriptLength,
1162                         NULL,
1163                         0,
1164                         trailing,
1165                         trailingLength,
1166                         minimizedLocaleID,
1167                         minimizedLocaleIDCapacity,
1168                         err);
1169         }
1170     }
1171
1172     {
1173         /**
1174          * If we got here, return the locale ID parameter.
1175          **/
1176         const int32_t localeIDLength = (int32_t)uprv_strlen(localeID);
1177
1178         uprv_memcpy(
1179             minimizedLocaleID,
1180             localeID,
1181             localeIDLength <= minimizedLocaleIDCapacity ?
1182                 localeIDLength : minimizedLocaleIDCapacity);
1183
1184         return u_terminateChars(
1185                     minimizedLocaleID,
1186                     minimizedLocaleIDCapacity,
1187                     localeIDLength,
1188                     err);
1189     }
1190
1191 error:
1192
1193     if (!U_FAILURE(*err)) {
1194         *err = U_ILLEGAL_ARGUMENT_ERROR;
1195     }
1196
1197     return -1;
1198
1199
1200 }
1201
1202 static UBool
1203 do_canonicalize(const char*    localeID,
1204          char* buffer,
1205          int32_t bufferCapacity,
1206          UErrorCode* err)
1207 {
1208     uloc_canonicalize(
1209         localeID,
1210         buffer,
1211         bufferCapacity,
1212         err);
1213
1214     if (*err == U_STRING_NOT_TERMINATED_WARNING ||
1215         *err == U_BUFFER_OVERFLOW_ERROR) {
1216         *err = U_ILLEGAL_ARGUMENT_ERROR;
1217
1218         return FALSE;
1219     }
1220     else if (U_FAILURE(*err)) {
1221
1222         return FALSE;
1223     }
1224     else {
1225         return TRUE;
1226     }
1227 }
1228
1229 U_CAPI int32_t U_EXPORT2
1230 uloc_addLikelySubtags(const char*    localeID,
1231          char* maximizedLocaleID,
1232          int32_t maximizedLocaleIDCapacity,
1233          UErrorCode* err)
1234 {
1235     char localeBuffer[ULOC_FULLNAME_CAPACITY];
1236
1237     if (!do_canonicalize(
1238         localeID,
1239         localeBuffer,
1240         sizeof(localeBuffer),
1241         err)) {
1242         return -1;
1243     }
1244     else {
1245         return _uloc_addLikelySubtags(
1246                     localeBuffer,
1247                     maximizedLocaleID,
1248                     maximizedLocaleIDCapacity,
1249                     err);
1250     }
1251 }
1252
1253 U_CAPI int32_t U_EXPORT2
1254 uloc_minimizeSubtags(const char*    localeID,
1255          char* minimizedLocaleID,
1256          int32_t minimizedLocaleIDCapacity,
1257          UErrorCode* err)
1258 {
1259     char localeBuffer[ULOC_FULLNAME_CAPACITY];
1260
1261     if (!do_canonicalize(
1262         localeID,
1263         localeBuffer,
1264         sizeof(localeBuffer),
1265         err)) {
1266         return -1;
1267     }
1268     else {
1269         return _uloc_minimizeSubtags(
1270                     localeBuffer,
1271                     minimizedLocaleID,
1272                     minimizedLocaleIDCapacity,
1273                     err);
1274     }
1275 }