The Tor Browser: intl/icu/source/common/loclikely.cpp@129ffea94266 (annotated)

intl/icu/source/common/loclikely.cpp@129ffea94266 (annotated)

intl/icu/source/common/loclikely.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
 *******************************************************************************
 *
 *   Copyright (C) 1997-2012, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  loclikely.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2010feb25
 *   created by: Markus W. Scherer
 *
 *   Code for likely and minimized locale subtags, separated out from other .cpp files
 *   that then do not depend on resource bundle code and likely-subtags data.
 */
 #include "unicode/utypes.h"
 #include "unicode/putil.h"
 #include "unicode/uloc.h"
 #include "unicode/ures.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "ulocimp.h"
 #include "ustr_imp.h"
 /**
  * This function looks for the localeID in the likelySubtags resource.
  *
  * @param localeID The tag to find.
  * @param buffer A buffer to hold the matching entry
  * @param bufferLength The length of the output buffer
  * @return A pointer to "buffer" if found, or a null pointer if not.
  */
 static const char*  U_CALLCONV
 findLikelySubtags(const char* localeID,
                   char* buffer,
                   int32_t bufferLength,
                   UErrorCode* err) {
     const char* result = NULL;
     if (!U_FAILURE(*err)) {
         int32_t resLen = 0;
         const UChar* s = NULL;
         UErrorCode tmpErr = U_ZERO_ERROR;
         UResourceBundle* subtags = ures_openDirect(NULL, "likelySubtags", &tmpErr);
         if (U_SUCCESS(tmpErr)) {
             s = ures_getStringByKey(subtags, localeID, &resLen, &tmpErr);
             if (U_FAILURE(tmpErr)) {
                 /*
                  * If a resource is missing, it's not really an error, it's
                  * just that we don't have any data for that particular locale ID.
                  */
                 if (tmpErr != U_MISSING_RESOURCE_ERROR) {
                     *err = tmpErr;
                 }
             }
             else if (resLen >= bufferLength) {
                 /* The buffer should never overflow. */
                 *err = U_INTERNAL_PROGRAM_ERROR;
             }
             else {
                 u_UCharsToChars(s, buffer, resLen + 1);
                 result = buffer;
             }
             ures_close(subtags);
         } else {
             *err = tmpErr;
         }
     }
     return result;
 }
 /**
  * Append a tag to a buffer, adding the separator if necessary.  The buffer
  * must be large enough to contain the resulting tag plus any separator
  * necessary. The tag must not be a zero-length string.
  *
  * @param tag The tag to add.
  * @param tagLength The length of the tag.
  * @param buffer The output buffer.
  * @param bufferLength The length of the output buffer.  This is an input/ouput parameter.
  **/
 static void U_CALLCONV
 appendTag(
     const char* tag,
     int32_t tagLength,
     char* buffer,
     int32_t* bufferLength) {
     if (*bufferLength > 0) {
         buffer[*bufferLength] = '_';
         ++(*bufferLength);
     }
     uprv_memmove(
         &buffer[*bufferLength],
         tag,
         tagLength);
     *bufferLength += tagLength;
 }
 /**
  * These are the canonical strings for unknown languages, scripts and regions.
  **/
 static const char* const unknownLanguage = "und";
 static const char* const unknownScript = "Zzzz";
 static const char* const unknownRegion = "ZZ";
 /**
  * Create a tag string from the supplied parameters.  The lang, script and region
  * parameters may be NULL pointers. If they are, their corresponding length parameters
  * must be less than or equal to 0.
  *
  * If any of the language, script or region parameters are empty, and the alternateTags
  * parameter is not NULL, it will be parsed for potential language, script and region tags
  * to be used when constructing the new tag.  If the alternateTags parameter is NULL, or
  * it contains no language tag, the default tag for the unknown language is used.
  *
  * If the length of the new string exceeds the capacity of the output buffer,
  * the function copies as many bytes to the output buffer as it can, and returns
  * the error U_BUFFER_OVERFLOW_ERROR.
  *
  * If an illegal argument is provided, the function returns the error
  * U_ILLEGAL_ARGUMENT_ERROR.
  *
  * Note that this function can return the warning U_STRING_NOT_TERMINATED_WARNING if
  * the tag string fits in the output buffer, but the null terminator doesn't.
  *
  * @param lang The language tag to use.
  * @param langLength The length of the language tag.
  * @param script The script tag to use.
  * @param scriptLength The length of the script tag.
  * @param region The region tag to use.
  * @param regionLength The length of the region tag.
  * @param trailing Any trailing data to append to the new tag.
  * @param trailingLength The length of the trailing data.
  * @param alternateTags A string containing any alternate tags.
  * @param tag The output buffer.
  * @param tagCapacity The capacity of the output buffer.
  * @param err A pointer to a UErrorCode for error reporting.
  * @return The length of the tag string, which may be greater than tagCapacity, or -1 on error.
  **/
 static int32_t U_CALLCONV
 createTagStringWithAlternates(
     const char* lang,
     int32_t langLength,
     const char* script,
     int32_t scriptLength,
     const char* region,
     int32_t regionLength,
     const char* trailing,
     int32_t trailingLength,
     const char* alternateTags,
     char* tag,
     int32_t tagCapacity,
     UErrorCode* err) {
     if (U_FAILURE(*err)) {
         goto error;
     }
     else if (tag == NULL ||
              tagCapacity <= 0 ||
              langLength >= ULOC_LANG_CAPACITY ||
              scriptLength >= ULOC_SCRIPT_CAPACITY ||
              regionLength >= ULOC_COUNTRY_CAPACITY) {
         goto error;
     }
     else {
         /**
          * ULOC_FULLNAME_CAPACITY will provide enough capacity
          * that we can build a string that contains the language,
          * script and region code without worrying about overrunning
          * the user-supplied buffer.
          **/
         char tagBuffer[ULOC_FULLNAME_CAPACITY];
         int32_t tagLength = 0;
         int32_t capacityRemaining = tagCapacity;
         UBool regionAppended = FALSE;
         if (langLength > 0) {
             appendTag(
                 lang,
                 langLength,
                 tagBuffer,
                 &tagLength);
         }
         else if (alternateTags == NULL) {
             /*
              * Append the value for an unknown language, if
              * we found no language.
              */
             appendTag(
                 unknownLanguage,
                 (int32_t)uprv_strlen(unknownLanguage),
                 tagBuffer,
                 &tagLength);
         }
         else {
             /*
              * Parse the alternateTags string for the language.
              */
             char alternateLang[ULOC_LANG_CAPACITY];
             int32_t alternateLangLength = sizeof(alternateLang);
             alternateLangLength =
                 uloc_getLanguage(
                     alternateTags,
                     alternateLang,
                     alternateLangLength,
                     err);
             if(U_FAILURE(*err) ||
                 alternateLangLength >= ULOC_LANG_CAPACITY) {
                 goto error;
             }
             else if (alternateLangLength == 0) {
                 /*
                  * Append the value for an unknown language, if
                  * we found no language.
                  */
                 appendTag(
                     unknownLanguage,
                     (int32_t)uprv_strlen(unknownLanguage),
                     tagBuffer,
                     &tagLength);
             }
             else {
                 appendTag(
                     alternateLang,
                     alternateLangLength,
                     tagBuffer,
                     &tagLength);
             }
         }
         if (scriptLength > 0) {
             appendTag(
                 script,
                 scriptLength,
                 tagBuffer,
                 &tagLength);
         }
         else if (alternateTags != NULL) {
             /*
              * Parse the alternateTags string for the script.
              */
             char alternateScript[ULOC_SCRIPT_CAPACITY];
             const int32_t alternateScriptLength =
                 uloc_getScript(
                     alternateTags,
                     alternateScript,
                     sizeof(alternateScript),
                     err);
             if (U_FAILURE(*err) ||
                 alternateScriptLength >= ULOC_SCRIPT_CAPACITY) {
                 goto error;
             }
             else if (alternateScriptLength > 0) {
                 appendTag(
                     alternateScript,
                     alternateScriptLength,
                     tagBuffer,
                     &tagLength);
             }
         }
         if (regionLength > 0) {
             appendTag(
                 region,
                 regionLength,
                 tagBuffer,
                 &tagLength);
             regionAppended = TRUE;
         }
         else if (alternateTags != NULL) {
             /*
              * Parse the alternateTags string for the region.
              */
             char alternateRegion[ULOC_COUNTRY_CAPACITY];
             const int32_t alternateRegionLength =
                 uloc_getCountry(
                     alternateTags,
                     alternateRegion,
                     sizeof(alternateRegion),
                     err);
             if (U_FAILURE(*err) ||
                 alternateRegionLength >= ULOC_COUNTRY_CAPACITY) {
                 goto error;
             }
             else if (alternateRegionLength > 0) {
                 appendTag(
                     alternateRegion,
                     alternateRegionLength,
                     tagBuffer,
                     &tagLength);
                 regionAppended = TRUE;
             }
         }
         {
             const int32_t toCopy =
                 tagLength >= tagCapacity ? tagCapacity : tagLength;
             /**
              * Copy the partial tag from our internal buffer to the supplied
              * target.
              **/
             uprv_memcpy(
                 tag,
                 tagBuffer,
                 toCopy);
             capacityRemaining -= toCopy;
         }
         if (trailingLength > 0) {
             if (*trailing != '@' && capacityRemaining > 0) {
                 tag[tagLength++] = '_';
                 --capacityRemaining;
                 if (capacityRemaining > 0 && !regionAppended) {
                     /* extra separator is required */
                     tag[tagLength++] = '_';
                     --capacityRemaining;
                 }
             }
             if (capacityRemaining > 0) {
                 /*
                  * Copy the trailing data into the supplied buffer.  Use uprv_memmove, since we
                  * don't know if the user-supplied buffers overlap.
                  */
                 const int32_t toCopy =
                     trailingLength >= capacityRemaining ? capacityRemaining : trailingLength;
                 uprv_memmove(
                     &tag[tagLength],
                     trailing,
                     toCopy);
             }
         }
         tagLength += trailingLength;
         return u_terminateChars(
                     tag,
                     tagCapacity,
                     tagLength,
                     err);
     }
 error:
     /**
      * An overflow indicates the locale ID passed in
      * is ill-formed.  If we got here, and there was
      * no previous error, it's an implicit overflow.
      **/
     if (*err ==  U_BUFFER_OVERFLOW_ERROR ||
         U_SUCCESS(*err)) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
     }
     return -1;
 }
 /**
  * Create a tag string from the supplied parameters.  The lang, script and region
  * parameters may be NULL pointers. If they are, their corresponding length parameters
  * must be less than or equal to 0.  If the lang parameter is an empty string, the
  * default value for an unknown language is written to the output buffer.
  *
  * If the length of the new string exceeds the capacity of the output buffer,
  * the function copies as many bytes to the output buffer as it can, and returns
  * the error U_BUFFER_OVERFLOW_ERROR.
  *
  * If an illegal argument is provided, the function returns the error
  * U_ILLEGAL_ARGUMENT_ERROR.
  *
  * @param lang The language tag to use.
  * @param langLength The length of the language tag.
  * @param script The script tag to use.
  * @param scriptLength The length of the script tag.
  * @param region The region tag to use.
  * @param regionLength The length of the region tag.
  * @param trailing Any trailing data to append to the new tag.
  * @param trailingLength The length of the trailing data.
  * @param tag The output buffer.
  * @param tagCapacity The capacity of the output buffer.
  * @param err A pointer to a UErrorCode for error reporting.
  * @return The length of the tag string, which may be greater than tagCapacity.
  **/
 static int32_t U_CALLCONV
 createTagString(
     const char* lang,
     int32_t langLength,
     const char* script,
     int32_t scriptLength,
     const char* region,
     int32_t regionLength,
     const char* trailing,
     int32_t trailingLength,
     char* tag,
     int32_t tagCapacity,
     UErrorCode* err)
 {
     return createTagStringWithAlternates(
                 lang,
                 langLength,
                 script,
                 scriptLength,
                 region,
                 regionLength,
                 trailing,
                 trailingLength,
                 NULL,
                 tag,
                 tagCapacity,
                 err);
 }
 /**
  * Parse the language, script, and region subtags from a tag string, and copy the
  * results into the corresponding output parameters. The buffers are null-terminated,
  * unless overflow occurs.
  *
  * The langLength, scriptLength, and regionLength parameters are input/output
  * parameters, and must contain the capacity of their corresponding buffers on
  * input.  On output, they will contain the actual length of the buffers, not
  * including the null terminator.
  *
  * If the length of any of the output subtags exceeds the capacity of the corresponding
  * buffer, the function copies as many bytes to the output buffer as it can, and returns
  * the error U_BUFFER_OVERFLOW_ERROR.  It will not parse any more subtags once overflow
  * occurs.
  *
  * If an illegal argument is provided, the function returns the error
  * U_ILLEGAL_ARGUMENT_ERROR.
  *
  * @param localeID The locale ID to parse.
  * @param lang The language tag buffer.
  * @param langLength The length of the language tag.
  * @param script The script tag buffer.
  * @param scriptLength The length of the script tag.
  * @param region The region tag buffer.
  * @param regionLength The length of the region tag.
  * @param err A pointer to a UErrorCode for error reporting.
  * @return The number of chars of the localeID parameter consumed.
  **/
 static int32_t U_CALLCONV
 parseTagString(
     const char* localeID,
     char* lang,
     int32_t* langLength,
     char* script,
     int32_t* scriptLength,
     char* region,
     int32_t* regionLength,
     UErrorCode* err)
 {
     const char* position = localeID;
     int32_t subtagLength = 0;
     if(U_FAILURE(*err) ||
        localeID == NULL ||
        lang == NULL ||
        langLength == NULL ||
        script == NULL ||
        scriptLength == NULL ||
        region == NULL ||
        regionLength == NULL) {
         goto error;
     }
     subtagLength = ulocimp_getLanguage(position, lang, *langLength, &position);
     u_terminateChars(lang, *langLength, subtagLength, err);
     /*
      * Note that we explicit consider U_STRING_NOT_TERMINATED_WARNING
      * to be an error, because it indicates the user-supplied tag is
      * not well-formed.
      */
     if(U_FAILURE(*err)) {
         goto error;
     }
     *langLength = subtagLength;
     /*
      * If no language was present, use the value of unknownLanguage
      * instead.  Otherwise, move past any separator.
      */
     if (*langLength == 0) {
         uprv_strcpy(
             lang,
             unknownLanguage);
         *langLength = (int32_t)uprv_strlen(lang);
     }
     else if (_isIDSeparator(*position)) {
         ++position;
     }
     subtagLength = ulocimp_getScript(position, script, *scriptLength, &position);
     u_terminateChars(script, *scriptLength, subtagLength, err);
     if(U_FAILURE(*err)) {
         goto error;
     }
     *scriptLength = subtagLength;
     if (*scriptLength > 0) {
         if (uprv_strnicmp(script, unknownScript, *scriptLength) == 0) {
             /**
              * If the script part is the "unknown" script, then don't return it.
              **/
             *scriptLength = 0;
         }
         /*
          * Move past any separator.
          */
         if (_isIDSeparator(*position)) {
             ++position;
         }
     }
     subtagLength = ulocimp_getCountry(position, region, *regionLength, &position);
     u_terminateChars(region, *regionLength, subtagLength, err);
     if(U_FAILURE(*err)) {
         goto error;
     }
     *regionLength = subtagLength;
     if (*regionLength > 0) {
         if (uprv_strnicmp(region, unknownRegion, *regionLength) == 0) {
             /**
              * If the region part is the "unknown" region, then don't return it.
              **/
             *regionLength = 0;
         }
     } else if (*position != 0 && *position != '@') {
         /* back up over consumed trailing separator */
         --position;
     }
 exit:
     return (int32_t)(position - localeID);
 error:
     /**
      * If we get here, we have no explicit error, it's the result of an
      * illegal argument.
      **/
     if (!U_FAILURE(*err)) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
     }
     goto exit;
 }
 static int32_t U_CALLCONV
 createLikelySubtagsString(
     const char* lang,
     int32_t langLength,
     const char* script,
     int32_t scriptLength,
     const char* region,
     int32_t regionLength,
     const char* variants,
     int32_t variantsLength,
     char* tag,
     int32_t tagCapacity,
     UErrorCode* err)
 {
     /**
      * ULOC_FULLNAME_CAPACITY will provide enough capacity
      * that we can build a string that contains the language,
      * script and region code without worrying about overrunning
      * the user-supplied buffer.
      **/
     char tagBuffer[ULOC_FULLNAME_CAPACITY];
     char likelySubtagsBuffer[ULOC_FULLNAME_CAPACITY];
     if(U_FAILURE(*err)) {
         goto error;
     }
     /**
      * Try the language with the script and region first.
      **/
     if (scriptLength > 0 && regionLength > 0) {
         const char* likelySubtags = NULL;
         createTagString(
             lang,
             langLength,
             script,
             scriptLength,
             region,
             regionLength,
             NULL,
 ,
             tagBuffer,
             sizeof(tagBuffer),
             err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         likelySubtags =
             findLikelySubtags(
                 tagBuffer,
                 likelySubtagsBuffer,
                 sizeof(likelySubtagsBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         if (likelySubtags != NULL) {
             /* Always use the language tag from the
                maximal string, since it may be more
                specific than the one provided. */
             return createTagStringWithAlternates(
                         NULL,
 ,
                         NULL,
 ,
                         NULL,
 ,
                         variants,
                         variantsLength,
                         likelySubtags,
                         tag,
                         tagCapacity,
                         err);
         }
     }
     /**
      * Try the language with just the script.
      **/
     if (scriptLength > 0) {
         const char* likelySubtags = NULL;
         createTagString(
             lang,
             langLength,
             script,
             scriptLength,
             NULL,
 ,
             NULL,
 ,
             tagBuffer,
             sizeof(tagBuffer),
             err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         likelySubtags =
             findLikelySubtags(
                 tagBuffer,
                 likelySubtagsBuffer,
                 sizeof(likelySubtagsBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         if (likelySubtags != NULL) {
             /* Always use the language tag from the
                maximal string, since it may be more
                specific than the one provided. */
             return createTagStringWithAlternates(
                         NULL,
 ,
                         NULL,
 ,
                         region,
                         regionLength,
                         variants,
                         variantsLength,
                         likelySubtags,
                         tag,
                         tagCapacity,
                         err);
         }
     }
     /**
      * Try the language with just the region.
      **/
     if (regionLength > 0) {
         const char* likelySubtags = NULL;
         createTagString(
             lang,
             langLength,
             NULL,
 ,
             region,
             regionLength,
             NULL,
 ,
             tagBuffer,
             sizeof(tagBuffer),
             err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         likelySubtags =
             findLikelySubtags(
                 tagBuffer,
                 likelySubtagsBuffer,
                 sizeof(likelySubtagsBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         if (likelySubtags != NULL) {
             /* Always use the language tag from the
                maximal string, since it may be more
                specific than the one provided. */
             return createTagStringWithAlternates(
                         NULL,
 ,
                         script,
                         scriptLength,
                         NULL,
 ,
                         variants,
                         variantsLength,
                         likelySubtags,
                         tag,
                         tagCapacity,
                         err);
         }
     }
     /**
      * Finally, try just the language.
      **/
     {
         const char* likelySubtags = NULL;
         createTagString(
             lang,
             langLength,
             NULL,
 ,
             NULL,
 ,
             NULL,
 ,
             tagBuffer,
             sizeof(tagBuffer),
             err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         likelySubtags =
             findLikelySubtags(
                 tagBuffer,
                 likelySubtagsBuffer,
                 sizeof(likelySubtagsBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         if (likelySubtags != NULL) {
             /* Always use the language tag from the
                maximal string, since it may be more
                specific than the one provided. */
             return createTagStringWithAlternates(
                         NULL,
 ,
                         script,
                         scriptLength,
                         region,
                         regionLength,
                         variants,
                         variantsLength,
                         likelySubtags,
                         tag,
                         tagCapacity,
                         err);
         }
     }
     return u_terminateChars(
                 tag,
                 tagCapacity,
 ,
                 err);
 error:
     if (!U_FAILURE(*err)) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
     }
     return -1;
 }
 #define CHECK_TRAILING_VARIANT_SIZE(trailing, trailingLength) \
     {   int32_t count = 0; \
         int32_t i; \
         for (i = 0; i < trailingLength; i++) { \
             if (trailing[i] == '-' || trailing[i] == '_') { \
                 count = 0; \
                 if (count > 8) { \
                     goto error; \
                 } \
             } else if (trailing[i] == '@') { \
                 break; \
             } else if (count > 8) { \
                 goto error; \
             } else { \
                 count++; \
             } \
         } \
     }
 static int32_t
 _uloc_addLikelySubtags(const char*    localeID,
          char* maximizedLocaleID,
          int32_t maximizedLocaleIDCapacity,
          UErrorCode* err)
 {
     char lang[ULOC_LANG_CAPACITY];
     int32_t langLength = sizeof(lang);
     char script[ULOC_SCRIPT_CAPACITY];
     int32_t scriptLength = sizeof(script);
     char region[ULOC_COUNTRY_CAPACITY];
     int32_t regionLength = sizeof(region);
     const char* trailing = "";
     int32_t trailingLength = 0;
     int32_t trailingIndex = 0;
     int32_t resultLength = 0;
     if(U_FAILURE(*err)) {
         goto error;
     }
     else if (localeID == NULL ||
              maximizedLocaleID == NULL ||
              maximizedLocaleIDCapacity <= 0) {
         goto error;
     }
     trailingIndex = parseTagString(
         localeID,
         lang,
         &langLength,
         script,
         &scriptLength,
         region,
         &regionLength,
         err);
     if(U_FAILURE(*err)) {
         /* Overflow indicates an illegal argument error */
         if (*err == U_BUFFER_OVERFLOW_ERROR) {
             *err = U_ILLEGAL_ARGUMENT_ERROR;
         }
         goto error;
     }
     /* Find the length of the trailing portion. */
     while (_isIDSeparator(localeID[trailingIndex])) {
         trailingIndex++;
     }
     trailing = &localeID[trailingIndex];
     trailingLength = (int32_t)uprv_strlen(trailing);
     CHECK_TRAILING_VARIANT_SIZE(trailing, trailingLength);
     resultLength =
         createLikelySubtagsString(
             lang,
             langLength,
             script,
             scriptLength,
             region,
             regionLength,
             trailing,
             trailingLength,
             maximizedLocaleID,
             maximizedLocaleIDCapacity,
             err);
     if (resultLength == 0) {
         const int32_t localIDLength = (int32_t)uprv_strlen(localeID);
         /*
          * If we get here, we need to return localeID.
          */
         uprv_memcpy(
             maximizedLocaleID,
             localeID,
             localIDLength <= maximizedLocaleIDCapacity ?
                 localIDLength : maximizedLocaleIDCapacity);
         resultLength =
             u_terminateChars(
                 maximizedLocaleID,
                 maximizedLocaleIDCapacity,
                 localIDLength,
                 err);
     }
     return resultLength;
 error:
     if (!U_FAILURE(*err)) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
     }
     return -1;
 }
 static int32_t
 _uloc_minimizeSubtags(const char*    localeID,
          char* minimizedLocaleID,
          int32_t minimizedLocaleIDCapacity,
          UErrorCode* err)
 {
     /**
      * ULOC_FULLNAME_CAPACITY will provide enough capacity
      * that we can build a string that contains the language,
      * script and region code without worrying about overrunning
      * the user-supplied buffer.
      **/
     char maximizedTagBuffer[ULOC_FULLNAME_CAPACITY];
     int32_t maximizedTagBufferLength = sizeof(maximizedTagBuffer);
     char lang[ULOC_LANG_CAPACITY];
     int32_t langLength = sizeof(lang);
     char script[ULOC_SCRIPT_CAPACITY];
     int32_t scriptLength = sizeof(script);
     char region[ULOC_COUNTRY_CAPACITY];
     int32_t regionLength = sizeof(region);
     const char* trailing = "";
     int32_t trailingLength = 0;
     int32_t trailingIndex = 0;
     if(U_FAILURE(*err)) {
         goto error;
     }
     else if (localeID == NULL ||
              minimizedLocaleID == NULL ||
              minimizedLocaleIDCapacity <= 0) {
         goto error;
     }
     trailingIndex =
         parseTagString(
             localeID,
             lang,
             &langLength,
             script,
             &scriptLength,
             region,
             &regionLength,
             err);
     if(U_FAILURE(*err)) {
         /* Overflow indicates an illegal argument error */
         if (*err == U_BUFFER_OVERFLOW_ERROR) {
             *err = U_ILLEGAL_ARGUMENT_ERROR;
         }
         goto error;
     }
     /* Find the spot where the variants or the keywords begin, if any. */
     while (_isIDSeparator(localeID[trailingIndex])) {
         trailingIndex++;
     }
     trailing = &localeID[trailingIndex];
     trailingLength = (int32_t)uprv_strlen(trailing);
     CHECK_TRAILING_VARIANT_SIZE(trailing, trailingLength);
     createTagString(
         lang,
         langLength,
         script,
         scriptLength,
         region,
         regionLength,
         NULL,
 ,
         maximizedTagBuffer,
         maximizedTagBufferLength,
         err);
     if(U_FAILURE(*err)) {
         goto error;
     }
     /**
      * First, we need to first get the maximization
      * from AddLikelySubtags.
      **/
     maximizedTagBufferLength =
         uloc_addLikelySubtags(
             maximizedTagBuffer,
             maximizedTagBuffer,
             maximizedTagBufferLength,
             err);
     if(U_FAILURE(*err)) {
         goto error;
     }
     /**
      * Start first with just the language.
      **/
     {
         char tagBuffer[ULOC_FULLNAME_CAPACITY];
         const int32_t tagBufferLength =
             createLikelySubtagsString(
                 lang,
                 langLength,
                 NULL,
 ,
                 NULL,
 ,
                 NULL,
 ,
                 tagBuffer,
                 sizeof(tagBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         else if (uprv_strnicmp(
                     maximizedTagBuffer,
                     tagBuffer,
                     tagBufferLength) == 0) {
             return createTagString(
                         lang,
                         langLength,
                         NULL,
 ,
                         NULL,
 ,
                         trailing,
                         trailingLength,
                         minimizedLocaleID,
                         minimizedLocaleIDCapacity,
                         err);
         }
     }
     /**
      * Next, try the language and region.
      **/
     if (regionLength > 0) {
         char tagBuffer[ULOC_FULLNAME_CAPACITY];
         const int32_t tagBufferLength =
             createLikelySubtagsString(
                 lang,
                 langLength,
                 NULL,
 ,
                 region,
                 regionLength,
                 NULL,
 ,
                 tagBuffer,
                 sizeof(tagBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         else if (uprv_strnicmp(
                     maximizedTagBuffer,
                     tagBuffer,
                     tagBufferLength) == 0) {
             return createTagString(
                         lang,
                         langLength,
                         NULL,
 ,
                         region,
                         regionLength,
                         trailing,
                         trailingLength,
                         minimizedLocaleID,
                         minimizedLocaleIDCapacity,
                         err);
         }
     }
     /**
      * Finally, try the language and script.  This is our last chance,
      * since trying with all three subtags would only yield the
      * maximal version that we already have.
      **/
     if (scriptLength > 0 && regionLength > 0) {
         char tagBuffer[ULOC_FULLNAME_CAPACITY];
         const int32_t tagBufferLength =
             createLikelySubtagsString(
                 lang,
                 langLength,
                 script,
                 scriptLength,
                 NULL,
 ,
                 NULL,
 ,
                 tagBuffer,
                 sizeof(tagBuffer),
                 err);
         if(U_FAILURE(*err)) {
             goto error;
         }
         else if (uprv_strnicmp(
                     maximizedTagBuffer,
                     tagBuffer,
                     tagBufferLength) == 0) {
             return createTagString(
                         lang,
                         langLength,
                         script,
                         scriptLength,
                         NULL,
 ,
                         trailing,
                         trailingLength,
                         minimizedLocaleID,
                         minimizedLocaleIDCapacity,
                         err);
         }
     }
     {
         /**
          * If we got here, return the locale ID parameter.
          **/
         const int32_t localeIDLength = (int32_t)uprv_strlen(localeID);
         uprv_memcpy(
             minimizedLocaleID,
             localeID,
             localeIDLength <= minimizedLocaleIDCapacity ?
                 localeIDLength : minimizedLocaleIDCapacity);
         return u_terminateChars(
                     minimizedLocaleID,
                     minimizedLocaleIDCapacity,
                     localeIDLength,
                     err);
     }
 error:
     if (!U_FAILURE(*err)) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
     }
     return -1;
 }
 static UBool
 do_canonicalize(const char*    localeID,
          char* buffer,
          int32_t bufferCapacity,
          UErrorCode* err)
 {
     uloc_canonicalize(
         localeID,
         buffer,
         bufferCapacity,
         err);
     if (*err == U_STRING_NOT_TERMINATED_WARNING ||
         *err == U_BUFFER_OVERFLOW_ERROR) {
         *err = U_ILLEGAL_ARGUMENT_ERROR;
         return FALSE;
     }
     else if (U_FAILURE(*err)) {
         return FALSE;
     }
     else {
         return TRUE;
     }
 }
 U_CAPI int32_t U_EXPORT2
 uloc_addLikelySubtags(const char*    localeID,
          char* maximizedLocaleID,
          int32_t maximizedLocaleIDCapacity,
          UErrorCode* err)
 {
     char localeBuffer[ULOC_FULLNAME_CAPACITY];
     if (!do_canonicalize(
         localeID,
         localeBuffer,
         sizeof(localeBuffer),
         err)) {
         return -1;
     }
     else {
         return _uloc_addLikelySubtags(
                     localeBuffer,
                     maximizedLocaleID,
                     maximizedLocaleIDCapacity,
                     err);
     }
 }
 U_CAPI int32_t U_EXPORT2
 uloc_minimizeSubtags(const char*    localeID,
          char* minimizedLocaleID,
          int32_t minimizedLocaleIDCapacity,
          UErrorCode* err)
 {
     char localeBuffer[ULOC_FULLNAME_CAPACITY];
     if (!do_canonicalize(
         localeID,
         localeBuffer,
         sizeof(localeBuffer),
         err)) {
         return -1;
     }
     else {
         return _uloc_minimizeSubtags(
                     localeBuffer,
                     minimizedLocaleID,
                     minimizedLocaleIDCapacity,
                     err);
     }
 }

The Tor Browser / annotate

intl/icu/source/common/loclikely.cpp@129ffea94266 (annotated)

intl/icu/source/common/loclikely.cpp