| /* |
| * Copyright 2009, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <ctype.h> |
| #include <string.h> |
| |
| namespace android { |
| |
| /* Generated by the following Python script. Values of country calling codes |
| are from http://en.wikipedia.org/wiki/List_of_country_calling_codes |
| |
| #!/usr/bin/python |
| import sys |
| ccc_set_2digits = set([0, 1, 7, |
| 20, 27, 28, 30, 31, 32, 33, 34, 36, 39, 40, 43, 44, 45, |
| 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 57, 58, 60, 61, |
| 62, 63, 64, 65, 66, 81, 82, 83, 84, 86, 89, 90, 91, 92, |
| 93, 94, 95, 98]) |
| |
| ONE_LINE_NUM = 10 |
| |
| for i in xrange(100): |
| if i % ONE_LINE_NUM == 0: |
| sys.stdout.write(' ') |
| if i in ccc_set_2digits: |
| included = 'true' |
| else: |
| included = 'false' |
| sys.stdout.write(included + ',') |
| if ((i + 1) % ONE_LINE_NUM) == 0: |
| sys.stdout.write('\n') |
| else: |
| sys.stdout.write(' ') |
| */ |
| static bool two_length_country_code_map[100] = { |
| true, true, false, false, false, false, false, true, false, false, |
| false, false, false, false, false, false, false, false, false, false, |
| true, false, false, false, false, false, false, true, true, false, |
| true, true, true, true, true, false, true, false, false, true, |
| true, false, false, true, true, true, true, true, true, true, |
| false, true, true, true, true, true, true, true, true, false, |
| true, true, true, true, true, true, true, false, false, false, |
| false, false, false, false, false, false, false, false, false, false, |
| false, true, true, true, true, false, true, false, false, true, |
| true, true, true, true, true, true, false, false, true, false, |
| }; |
| |
| #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) |
| |
| /** |
| * Returns true if "ccc_candidate" expresses (part of ) some country calling |
| * code. |
| * Returns false otherwise. |
| */ |
| static bool isCountryCallingCode(int ccc_candidate) { |
| return ccc_candidate > 0 && |
| ccc_candidate < (int)ARRAY_SIZE(two_length_country_code_map) && |
| two_length_country_code_map[ccc_candidate]; |
| } |
| |
| /** |
| * Returns interger corresponding to the input if input "ch" is |
| * ISO-LATIN characters 0-9. |
| * Returns -1 otherwise |
| */ |
| static int tryGetISODigit (char ch) |
| { |
| if ('0' <= ch && ch <= '9') { |
| return ch - '0'; |
| } else { |
| return -1; |
| } |
| } |
| |
| /** |
| * True if ch is ISO-LATIN characters 0-9, *, # , + |
| * Note this method current does not account for the WILD char 'N' |
| */ |
| static bool isDialable(char ch) |
| { |
| return ('0' <= ch && ch <= '9') || ch == '*' || ch == '#' || ch == '+'; |
| } |
| |
| /** Returns true if ch is not dialable or alpha char */ |
| static bool isSeparator(char ch) |
| { |
| return !isDialable(ch) && (isalpha(ch) == 0); |
| } |
| |
| /** |
| * Try to store the pointer to "new_ptr" which does not have trunk prefix. |
| * |
| * Currently this function simply ignore the first digit assuming it is |
| * trunk prefix. Actually trunk prefix is different in each country. |
| * |
| * e.g. |
| * "+79161234567" equals "89161234567" (Russian trunk digit is 8) |
| * "+33123456789" equals "0123456789" (French trunk digit is 0) |
| * |
| */ |
| static bool tryGetTrunkPrefixOmittedStr(const char *str, size_t len, |
| const char **new_ptr, size_t *new_len) |
| { |
| for (size_t i = 0 ; i < len ; i++) { |
| char ch = str[i]; |
| if (tryGetISODigit(ch) >= 0) { |
| if (new_ptr != NULL) { |
| *new_ptr = str + i + 1; |
| } |
| if (new_len != NULL) { |
| *new_len = len - (i + 1); |
| } |
| return true; |
| } else if (isDialable(ch)) { |
| return false; |
| } |
| } |
| |
| return false; |
| } |
| |
| /* |
| * Note that this function does not strictly care the country calling code with |
| * 3 length (like Morocco: +212), assuming it is enough to use the first two |
| * digit to compare two phone numbers. |
| */ |
| static int tryGetCountryCallingCode(const char *str, size_t len, |
| const char **new_ptr, size_t *new_len, |
| bool accept_thailand_case) |
| { |
| // Rough regexp: |
| // ^[^0-9*#+]*((\+|0(0|11)\d\d?|166) [^0-9*#+] $ |
| // 0 1 2 3 45 6 7 89 |
| // |
| // In all the states, this function ignores separator characters. |
| // "166" is the special case for the call from Thailand to the US. Ugu! |
| |
| int state = 0; |
| int ccc = 0; |
| for (size_t i = 0 ; i < len ; i++ ) { |
| char ch = str[i]; |
| switch (state) { |
| case 0: |
| if (ch == '+') state = 1; |
| else if (ch == '0') state = 2; |
| else if (ch == '1') { |
| if (accept_thailand_case) { |
| state = 8; |
| } else { |
| return -1; |
| } |
| } else if (isDialable(ch)) return -1; |
| break; |
| |
| case 2: |
| if (ch == '0') state = 3; |
| else if (ch == '1') state = 4; |
| else if (isDialable(ch)) return -1; |
| break; |
| |
| case 4: |
| if (ch == '1') state = 5; |
| else if (isDialable(ch)) return -1; |
| break; |
| |
| case 1: |
| case 3: |
| case 5: |
| case 6: |
| case 7: |
| { |
| int ret = tryGetISODigit(ch); |
| if (ret > 0) { |
| ccc = ccc * 10 + ret; |
| if (ccc >= 100 || isCountryCallingCode(ccc)) { |
| if (new_ptr != NULL) { |
| *new_ptr = str + i + 1; |
| } |
| if (new_len != NULL) { |
| *new_len = len - (i + 1); |
| } |
| return ccc; |
| } |
| if (state == 1 || state == 3 || state == 5) { |
| state = 6; |
| } else { |
| state++; |
| } |
| } else if (isDialable(ch)) { |
| return -1; |
| } |
| } |
| break; |
| case 8: |
| if (ch == '6') state = 9; |
| else if (isDialable(ch)) return -1; |
| break; |
| case 9: |
| if (ch == '6') { |
| if (new_ptr != NULL) { |
| *new_ptr = str + i + 1; |
| } |
| if (new_len != NULL) { |
| *new_len = len - (i + 1); |
| } |
| return 66; |
| } else { |
| return -1; |
| } |
| break; |
| default: |
| return -1; |
| } |
| } |
| |
| return -1; |
| } |
| |
| /** |
| * Return true if the prefix of "ch" is "ignorable". Here, "ignorable" means |
| * that "ch" has only one digit and separater characters. The one digit is |
| * assumed to be trunk prefix. |
| */ |
| static bool checkPrefixIsIgnorable(const char* ch, int i) { |
| bool trunk_prefix_was_read = false; |
| while (i >= 0) { |
| if (tryGetISODigit(ch[i]) >= 0) { |
| if (trunk_prefix_was_read) { |
| // More than one digit appeared, meaning that "a" and "b" |
| // is different. |
| return false; |
| } else { |
| // Ignore just one digit, assuming it is trunk prefix. |
| trunk_prefix_was_read = true; |
| } |
| } else if (isDialable(ch[i])) { |
| // Trunk prefix is a digit, not "*", "#"... |
| return false; |
| } |
| i--; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Compare phone numbers a and b, return true if they're identical |
| * enough for caller ID purposes. |
| * |
| * Assume NULL as 0-length string. |
| * |
| * Detailed information: |
| * Currently (as of 2009-06-12), we cannot depend on the locale given from the |
| * OS. For example, current Android does not accept "en_JP", meaning |
| * "the display language is English but the phone should be in Japan", but |
| * en_US, es_US, etc. So we cannot identify which digit is valid trunk prefix |
| * in the country where the phone is used. More specifically, "880-1234-1234" |
| * is not valid phone number in Japan since the trunk prefix in Japan is not 8 |
| * but 0 (correct number should be "080-1234-1234"), while Russian trunk prefix |
| * is 8. Also, we cannot know whether the country where users live has trunk |
| * prefix itself. So, we cannot determine whether "+81-80-1234-1234" is NOT |
| * same as "880-1234-1234" (while "+81-80-1234-1234" is same as "080-1234-1234" |
| * and we can determine "880-1234-1234" is different from "080-1234-1234"). |
| * |
| * In the future, we should handle trunk prefix more correctly, but as of now, |
| * we just ignore it... |
| */ |
| static bool phone_number_compare_inter(const char* const org_a, const char* const org_b, |
| bool accept_thailand_case) |
| { |
| const char* a = org_a; |
| const char* b = org_b; |
| size_t len_a = 0; |
| size_t len_b = 0; |
| if (a == NULL) { |
| a = ""; |
| } else { |
| len_a = strlen(a); |
| } |
| if (b == NULL) { |
| b = ""; |
| } else { |
| len_b = strlen(b); |
| } |
| |
| const char* tmp_a = NULL; |
| const char* tmp_b = NULL; |
| size_t tmp_len_a = len_a; |
| size_t tmp_len_b = len_b; |
| |
| int ccc_a = tryGetCountryCallingCode(a, len_a, &tmp_a, &tmp_len_a, accept_thailand_case); |
| int ccc_b = tryGetCountryCallingCode(b, len_b, &tmp_b, &tmp_len_b, accept_thailand_case); |
| bool both_have_ccc = false; |
| bool ok_to_ignore_prefix = true; |
| bool trunk_prefix_is_omitted_a = false; |
| bool trunk_prefix_is_omitted_b = false; |
| if (ccc_a >= 0 && ccc_b >= 0) { |
| if (ccc_a != ccc_b) { |
| // Different Country Calling Code. Must be different phone number. |
| return false; |
| } |
| // When both have ccc, do not ignore trunk prefix. Without this, |
| // "+81123123" becomes same as "+810123123" (+81 == Japan) |
| ok_to_ignore_prefix = false; |
| both_have_ccc = true; |
| } else if (ccc_a < 0 && ccc_b < 0) { |
| // When both do not have ccc, do not ignore trunk prefix. Without this, |
| // "123123" becomes same as "0123123" |
| ok_to_ignore_prefix = false; |
| } else { |
| if (ccc_a < 0) { |
| tryGetTrunkPrefixOmittedStr(a, len_a, &tmp_a, &tmp_len_a); |
| trunk_prefix_is_omitted_a = true; |
| } |
| if (ccc_b < 0) { |
| tryGetTrunkPrefixOmittedStr(b, len_b, &tmp_b, &tmp_len_b); |
| trunk_prefix_is_omitted_b = true; |
| } |
| } |
| |
| if (tmp_a != NULL) { |
| a = tmp_a; |
| len_a = tmp_len_a; |
| } |
| if (tmp_b != NULL) { |
| b = tmp_b; |
| len_b = tmp_len_b; |
| } |
| |
| int i_a = len_a - 1; |
| int i_b = len_b - 1; |
| while (i_a >= 0 && i_b >= 0) { |
| bool skip_compare = false; |
| char ch_a = a[i_a]; |
| char ch_b = b[i_b]; |
| if (isSeparator(ch_a)) { |
| i_a--; |
| skip_compare = true; |
| } |
| if (isSeparator(ch_b)) { |
| i_b--; |
| skip_compare = true; |
| } |
| |
| if (!skip_compare) { |
| if (ch_a != ch_b) { |
| return false; |
| } |
| i_a--; |
| i_b--; |
| } |
| } |
| |
| if (ok_to_ignore_prefix) { |
| if ((trunk_prefix_is_omitted_a && i_a >= 0) || |
| !checkPrefixIsIgnorable(a, i_a)) { |
| if (accept_thailand_case) { |
| // Maybe the code handling the special case for Thailand makes the |
| // result garbled, so disable the code and try again. |
| // e.g. "16610001234" must equal to "6610001234", but with |
| // Thailand-case handling code, they become equal to each other. |
| // |
| // Note: we select simplicity rather than adding some complicated |
| // logic here for performance(like "checking whether remaining |
| // numbers are just 66 or not"), assuming inputs are small |
| // enough. |
| return phone_number_compare_inter(org_a, org_b, false); |
| } else { |
| return false; |
| } |
| } |
| if ((trunk_prefix_is_omitted_b && i_b >= 0) || |
| !checkPrefixIsIgnorable(b, i_b)) { |
| if (accept_thailand_case) { |
| return phone_number_compare_inter(org_a, org_b, false); |
| } else { |
| return false; |
| } |
| } |
| } else { |
| // In the US, 1-650-555-1234 must be equal to 650-555-1234, |
| // while 090-1234-1234 must not be equalt to 90-1234-1234 in Japan. |
| // This request exists just in US (with 1 trunk (NDD) prefix). |
| // In addition, "011 11 7005554141" must not equal to "+17005554141", |
| // while "011 1 7005554141" must equal to "+17005554141" |
| // |
| // In this comparison, we ignore the prefix '1' just once, when |
| // - at least either does not have CCC, or |
| // - the remaining non-separator number is 1 |
| bool may_be_namp = !both_have_ccc; |
| while (i_a >= 0) { |
| const char ch_a = a[i_a]; |
| if (isDialable(ch_a)) { |
| if (may_be_namp && tryGetISODigit(ch_a) == 1) { |
| may_be_namp = false; |
| } else { |
| return false; |
| } |
| } |
| i_a--; |
| } |
| while (i_b >= 0) { |
| const char ch_b = b[i_b]; |
| if (isDialable(ch_b)) { |
| if (may_be_namp && tryGetISODigit(ch_b) == 1) { |
| may_be_namp = false; |
| } else { |
| return false; |
| } |
| } |
| i_b--; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool phone_number_compare_strict(const char* a, const char* b) |
| { |
| return phone_number_compare_inter(a, b, true); |
| } |
| |
| /** |
| * Imitates the Java method PhoneNumberUtils.getStrippedReversed. |
| * Used for API compatibility with Android 1.6 and earlier. |
| */ |
| bool phone_number_stripped_reversed_inter(const char* in, char* out, const int len, int *outlen) { |
| int in_len = strlen(in); |
| int out_len = 0; |
| bool have_seen_plus = false; |
| for (int i = in_len; --i >= 0;) { |
| char c = in[i]; |
| if ((c >= '0' && c <= '9') || c == '*' || c == '#' || c == 'N') { |
| if (out_len < len) { |
| out[out_len++] = c; |
| } |
| } else { |
| switch (c) { |
| case '+': |
| if (!have_seen_plus) { |
| if (out_len < len) { |
| out[out_len++] = c; |
| } |
| have_seen_plus = true; |
| } |
| break; |
| case ',': |
| case ';': |
| out_len = 0; |
| break; |
| } |
| } |
| } |
| |
| *outlen = out_len; |
| return true; |
| } |
| |
| } // namespace android |
