libs/androidfw/LocaleData.cpp

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <array>
  18 #include <cstdint>
  19 #include <cstdlib>
  20 #include <cstring>
  21 #include <string>
  22 #include <unordered_map>
  23 #include <unordered_set>
  24
  25 #include <androidfw/LocaleData.h>
  26
  27 namespace android {
  28
  29 #include "LocaleDataTables.cpp"
  30
  31 inline uint32_t packLocale(const char* language, const char* region) {
  32     return (((uint8_t) language[0]) << 24u) | (((uint8_t) language[1]) << 16u) |
  33            (((uint8_t) region[0]) << 8u) | ((uint8_t) region[1]);
  34 }
  35
  36 inline uint32_t dropRegion(uint32_t packed_locale) {
  37     return packed_locale & 0xFFFF0000lu;
  38 }
  39
  40 inline bool hasRegion(uint32_t packed_locale) {
  41     return (packed_locale & 0x0000FFFFlu) != 0;
  42 }
  43
  44 const size_t SCRIPT_LENGTH = 4;
  45 const size_t SCRIPT_PARENTS_COUNT = sizeof(SCRIPT_PARENTS)/sizeof(SCRIPT_PARENTS[0]);
  46 const uint32_t PACKED_ROOT = 0; // to represent the root locale
  47
  48 uint32_t findParent(uint32_t packed_locale, const char* script) {
  49     if (hasRegion(packed_locale)) {
  50         for (size_t i = 0; i < SCRIPT_PARENTS_COUNT; i++) {
  51             if (memcmp(script, SCRIPT_PARENTS[i].script, SCRIPT_LENGTH) == 0) {
  52                 auto map = SCRIPT_PARENTS[i].map;
  53                 auto lookup_result = map->find(packed_locale);
  54                 if (lookup_result != map->end()) {
  55                     return lookup_result->second;
  56                 }
  57                 break;
  58             }
  59         }
  60         return dropRegion(packed_locale);
  61     }
  62     return PACKED_ROOT;
  63 }
  64
  65 // Find the ancestors of a locale, and fill 'out' with it (assumes out has enough
  66 // space). If any of the members of stop_list was seen, write it in the
  67 // output but stop afterwards.
  68 //
  69 // This also outputs the index of the last written ancestor in the stop_list
  70 // to stop_list_index, which will be -1 if it is not found in the stop_list.
  71 //
  72 // Returns the number of ancestors written in the output, which is always
  73 // at least one.
  74 //
  75 // (If 'out' is nullptr, we do everything the same way but we simply don't write
  76 // any results in 'out'.)
  77 size_t findAncestors(uint32_t* out, ssize_t* stop_list_index,
  78                      uint32_t packed_locale, const char* script,
  79                      const uint32_t* stop_list, size_t stop_set_length) {
  80     uint32_t ancestor = packed_locale;
  81     size_t count = 0;
  82     do {
  83         if (out != nullptr) out[count] = ancestor;
  84         count++;
  85         for (size_t i = 0; i < stop_set_length; i++) {
  86             if (stop_list[i] == ancestor) {
  87                 *stop_list_index = (ssize_t) i;
  88                 return count;
  89             }
  90         }
  91         ancestor = findParent(ancestor, script);
  92     } while (ancestor != PACKED_ROOT);
  93     *stop_list_index = (ssize_t) -1;
  94     return count;
  95 }
  96
  97 size_t findDistance(uint32_t supported,
  98                     const char* script,
  99                     const uint32_t* request_ancestors,
 100                     size_t request_ancestors_count) {
 101     ssize_t request_ancestors_index;
 102     const size_t supported_ancestor_count = findAncestors(
 103             nullptr, &request_ancestors_index,
 104             supported, script,
 105             request_ancestors, request_ancestors_count);
 106     // Since both locales share the same root, there will always be a shared
 107     // ancestor, so the distance in the parent tree is the sum of the distance
 108     // of 'supported' to the lowest common ancestor (number of ancestors
 109     // written for 'supported' minus 1) plus the distance of 'request' to the
 110     // lowest common ancestor (the index of the ancestor in request_ancestors).
 111     return supported_ancestor_count + request_ancestors_index - 1;
 112 }
 113
 114 inline bool isRepresentative(uint32_t language_and_region, const char* script) {
 115     const uint64_t packed_locale = (
 116             (((uint64_t) language_and_region) << 32u) |
 117             (((uint64_t) script[0]) << 24u) |
 118             (((uint64_t) script[1]) << 16u) |
 119             (((uint64_t) script[2]) <<  8u) |
 120             ((uint64_t) script[3]));
 121
 122     return (REPRESENTATIVE_LOCALES.count(packed_locale) != 0);
 123 }
 124
 125 const uint32_t US_SPANISH = 0x65735553lu; // es-US
 126 const uint32_t MEXICAN_SPANISH = 0x65734D58lu; // es-MX
 127 const uint32_t LATIN_AMERICAN_SPANISH = 0x6573A424lu; // es-419
 128
 129 // The two locales es-US and es-MX are treated as special fallbacks for es-419.
 130 // If there is no es-419, they are considered its equivalent.
 131 inline bool isSpecialSpanish(uint32_t language_and_region) {
 132     return (language_and_region == US_SPANISH || language_and_region == MEXICAN_SPANISH);
 133 }
 134
 135 int localeDataCompareRegions(
 136         const char* left_region, const char* right_region,
 137         const char* requested_language, const char* requested_script,
 138         const char* requested_region) {
 139
 140     if (left_region[0] == right_region[0] && left_region[1] == right_region[1]) {
 141         return 0;
 142     }
 143     uint32_t left = packLocale(requested_language, left_region);
 144     uint32_t right = packLocale(requested_language, right_region);
 145     const uint32_t request = packLocale(requested_language, requested_region);
 146
 147     // If one and only one of the two locales is a special Spanish locale, we
 148     // replace it with es-419. We don't do the replacement if the other locale
 149     // is already es-419, or both locales are special Spanish locales (when
 150     // es-US is being compared to es-MX).
 151     const bool leftIsSpecialSpanish = isSpecialSpanish(left);
 152     const bool rightIsSpecialSpanish = isSpecialSpanish(right);
 153     if (leftIsSpecialSpanish && !rightIsSpecialSpanish && right != LATIN_AMERICAN_SPANISH) {
 154         left = LATIN_AMERICAN_SPANISH;
 155     } else if (rightIsSpecialSpanish && !leftIsSpecialSpanish && left != LATIN_AMERICAN_SPANISH) {
 156         right = LATIN_AMERICAN_SPANISH;
 157     }
 158
 159     uint32_t request_ancestors[MAX_PARENT_DEPTH+1];
 160     ssize_t left_right_index;
 161     // Find the parents of the request, but stop as soon as we saw left or right
 162     const std::array<uint32_t, 2> left_and_right = {{left, right}};
 163     const size_t ancestor_count = findAncestors(
 164             request_ancestors, &left_right_index,
 165             request, requested_script,
 166             left_and_right.data(), left_and_right.size());
 167     if (left_right_index == 0) { // We saw left earlier
 168         return 1;
 169     }
 170     if (left_right_index == 1) { // We saw right earlier
 171         return -1;
 172     }
 173
 174     // If we are here, neither left nor right are an ancestor of the
 175     // request. This means that all the ancestors have been computed and
 176     // the last ancestor is just the language by itself. We will use the
 177     // distance in the parent tree for determining the better match.
 178     const size_t left_distance = findDistance(
 179             left, requested_script, request_ancestors, ancestor_count);
 180     const size_t right_distance = findDistance(
 181             right, requested_script, request_ancestors, ancestor_count);
 182     if (left_distance != right_distance) {
 183         return (int) right_distance - (int) left_distance; // smaller distance is better
 184     }
 185
 186     // If we are here, left and right are equidistant from the request. We will
 187     // try and see if any of them is a representative locale.
 188     const bool left_is_representative = isRepresentative(left, requested_script);
 189     const bool right_is_representative = isRepresentative(right, requested_script);
 190     if (left_is_representative != right_is_representative) {
 191         return (int) left_is_representative - (int) right_is_representative;
 192     }
 193
 194     // We have no way of figuring out which locale is a better match. For
 195     // the sake of stability, we consider the locale with the lower region
 196     // code (in dictionary order) better, with two-letter codes before
 197     // three-digit codes (since two-letter codes are more specific).
 198     return (int64_t) right - (int64_t) left;
 199 }
 200
 201 void localeDataComputeScript(char out[4], const char* language, const char* region) {
 202     if (language[0] == '\0') {
 203         memset(out, '\0', SCRIPT_LENGTH);
 204         return;
 205     }
 206     uint32_t lookup_key = packLocale(language, region);
 207     auto lookup_result = LIKELY_SCRIPTS.find(lookup_key);
 208     if (lookup_result == LIKELY_SCRIPTS.end()) {
 209         // We couldn't find the locale. Let's try without the region
 210         if (region[0] != '\0') {
 211             lookup_key = dropRegion(lookup_key);
 212             lookup_result = LIKELY_SCRIPTS.find(lookup_key);
 213             if (lookup_result != LIKELY_SCRIPTS.end()) {
 214                 memcpy(out, SCRIPT_CODES[lookup_result->second], SCRIPT_LENGTH);
 215                 return;
 216             }
 217         }
 218         // We don't know anything about the locale
 219         memset(out, '\0', SCRIPT_LENGTH);
 220         return;
 221     } else {
 222         // We found the locale.
 223         memcpy(out, SCRIPT_CODES[lookup_result->second], SCRIPT_LENGTH);
 224     }
 225 }
 226
 227 const uint32_t ENGLISH_STOP_LIST[2] = {
 228     0x656E0000lu, // en
 229     0x656E8400lu, // en-001
 230 };
 231 const char ENGLISH_CHARS[2] = {'e', 'n'};
 232 const char LATIN_CHARS[4] = {'L', 'a', 't', 'n'};
 233
 234 bool localeDataIsCloseToUsEnglish(const char* region) {
 235     const uint32_t locale = packLocale(ENGLISH_CHARS, region);
 236     ssize_t stop_list_index;
 237     findAncestors(nullptr, &stop_list_index, locale, LATIN_CHARS, ENGLISH_STOP_LIST, 2);
 238     // A locale is like US English if we see "en" before "en-001" in its ancestor list.
 239     return stop_list_index == 0; // 'en' is first in ENGLISH_STOP_LIST
 240 }
 241
 242 } // namespace android