| // Copyright (C) 2011 The Libphonenumber Authors |
| // |
| // 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. |
| // |
| // Author: Lara Rennie |
| // Author: Tao Huang |
| // |
| // Implementation of a stateful class that finds and extracts telephone numbers |
| // from text. |
| |
| #include "phonenumbers/phonenumbermatcher.h" |
| |
| #ifndef I18N_PHONENUMBERS_USE_ICU_REGEXP |
| #error phonenumbermatcher depends on ICU \ |
| (i.e. I18N_PHONENUMBERS_USE_ICU_REGEXP must be set) |
| #endif // I18N_PHONENUMBERS_USE_ICU_REGEXP |
| |
| #include <ctype.h> |
| #include <stddef.h> |
| #include <limits> |
| #include <map> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include <unicode/uchar.h> |
| |
| #include "phonenumbers/alternate_format.h" |
| #include "phonenumbers/base/logging.h" |
| #include "phonenumbers/base/memory/scoped_ptr.h" |
| #include "phonenumbers/base/memory/singleton.h" |
| #include "phonenumbers/callback.h" |
| #include "phonenumbers/default_logger.h" |
| #include "phonenumbers/encoding_utils.h" |
| #include "phonenumbers/normalize_utf8.h" |
| #include "phonenumbers/phonemetadata.pb.h" |
| #include "phonenumbers/phonenumber.pb.h" |
| #include "phonenumbers/phonenumbermatch.h" |
| #include "phonenumbers/phonenumberutil.h" |
| #include "phonenumbers/regexp_adapter.h" |
| #include "phonenumbers/regexp_adapter_icu.h" |
| #include "phonenumbers/stringutil.h" |
| |
| #ifdef I18N_PHONENUMBERS_USE_RE2 |
| #include "phonenumbers/regexp_adapter_re2.h" |
| #endif // I18N_PHONENUMBERS_USE_RE2_AND_ICU |
| |
| using std::make_pair; |
| using std::map; |
| using std::numeric_limits; |
| using std::string; |
| using std::vector; |
| |
| namespace i18n { |
| namespace phonenumbers { |
| |
| namespace { |
| // Returns a regular expression quantifier with an upper and lower limit. |
| string Limit(int lower, int upper) { |
| DCHECK_GE(lower, 0); |
| DCHECK_GT(upper, 0); |
| DCHECK_LT(lower, upper); |
| return StrCat("{", lower, ",", upper, "}"); |
| } |
| |
| bool IsInvalidPunctuationSymbol(char32 character) { |
| return character == '%' || u_charType(character) == U_CURRENCY_SYMBOL; |
| } |
| |
| bool ContainsOnlyValidXChars(const PhoneNumber& number, const string& candidate, |
| const PhoneNumberUtil& util) { |
| // The characters 'x' and 'X' can be (1) a carrier code, in which case they |
| // always precede the national significant number or (2) an extension sign, |
| // in which case they always precede the extension number. We assume a |
| // carrier code is more than 1 digit, so the first case has to have more than |
| // 1 consecutive 'x' or 'X', whereas the second case can only have exactly 1 |
| // 'x' or 'X'. |
| size_t found; |
| found = candidate.find_first_of("xX"); |
| // We ignore the character if 'x' or 'X' appears as the last character of |
| // the string. |
| while (found != string::npos && found < candidate.length() - 1) { |
| // We only look for 'x' or 'X' in ASCII form. |
| char next_char = candidate[found + 1]; |
| if (next_char == 'x' || next_char == 'X') { |
| // This is the carrier code case, in which the 'X's always precede the |
| // national significant number. |
| ++found; |
| if (util.IsNumberMatchWithOneString( |
| number, candidate.substr(found, candidate.length() - found)) |
| != PhoneNumberUtil::NSN_MATCH) { |
| return false; |
| } |
| } else { |
| string normalized_extension(candidate.substr(found, |
| candidate.length() - found)); |
| util.NormalizeDigitsOnly(&normalized_extension); |
| if (normalized_extension != number.extension()) { |
| return false; |
| } |
| } |
| found = candidate.find_first_of("xX", found + 1); |
| } |
| return true; |
| } |
| |
| bool AllNumberGroupsRemainGrouped( |
| const PhoneNumberUtil& util, |
| const PhoneNumber& phone_number, |
| const string& normalized_candidate, |
| const vector<string>& formatted_number_groups) { |
| size_t from_index = 0; |
| // Check each group of consecutive digits are not broken into separate |
| // groupings in the normalized_candidate string. |
| for (size_t i = 0; i < formatted_number_groups.size(); ++i) { |
| // Fails if the substring of normalized_candidate starting from from_index |
| // doesn't contain the consecutive digits in formatted_number_groups.at(i). |
| from_index = normalized_candidate.find(formatted_number_groups.at(i), |
| from_index); |
| if (from_index == string::npos) { |
| return false; |
| } |
| // Moves from_index forward. |
| from_index += formatted_number_groups.at(i).length(); |
| if (i == 0 && from_index < normalized_candidate.length()) { |
| // We are at the position right after the NDC. We get the region used for |
| // formatting information based on the country code in the phone number, |
| // rather than the number itself, as we do not need to distinguish between |
| // different countries with the same country calling code and this is |
| // faster. |
| string region; |
| util.GetRegionCodeForCountryCode(phone_number.country_code(), ®ion); |
| string ndd_prefix; |
| util.GetNddPrefixForRegion(region, true, &ndd_prefix); |
| // Note although normalized_candidate might contain non-ASCII formatting |
| // characters, they won't be treated as ASCII digits when converted to a |
| // char. |
| if (!ndd_prefix.empty() && isdigit(normalized_candidate.at(from_index))) { |
| // This means there is no formatting symbol after the NDC. In this case, |
| // we only accept the number if there is no formatting symbol at all in |
| // the number, except for extensions. This is only important for |
| // countries with national prefixes. |
| string national_significant_number; |
| util.GetNationalSignificantNumber( |
| phone_number, &national_significant_number); |
| return HasPrefixString(normalized_candidate.substr( |
| from_index - formatted_number_groups.at(i).length()), |
| national_significant_number); |
| } |
| } |
| } |
| // The check here makes sure that we haven't mistakenly already used the |
| // extension to match the last group of the subscriber number. Note the |
| // extension cannot have formatting in-between digits. |
| return normalized_candidate.substr(from_index) |
| .find(phone_number.extension()) != string::npos; |
| } |
| |
| bool LoadAlternateFormats(PhoneMetadataCollection* alternate_formats) { |
| #if defined(I18N_PHONENUMBERS_USE_ALTERNATE_FORMATS) |
| if (!alternate_formats->ParseFromArray(alternate_format_get(), |
| alternate_format_size())) { |
| LOG(ERROR) << "Could not parse binary data."; |
| return false; |
| } |
| return true; |
| #else |
| return false; |
| #endif |
| } |
| |
| } // namespace |
| |
| class PhoneNumberMatcherRegExps : public Singleton<PhoneNumberMatcherRegExps> { |
| private: |
| friend class Singleton<PhoneNumberMatcherRegExps>; |
| |
| string opening_parens_; |
| string closing_parens_; |
| string non_parens_; |
| // Limit on the number of pairs of brackets in a phone number. |
| string bracket_pair_limit_; |
| // Helper strings for the matching_brackets_ pattern. |
| // An opening bracket at the beginning may not be closed, but subsequent ones |
| // should be. It's also possible that the leading bracket was dropped, so we |
| // shouldn't be surprised if we see a closing bracket first. |
| string leading_maybe_matched_bracket_; |
| string bracket_pairs_; |
| // Limit on the number of leading (plus) characters. |
| string lead_limit_; |
| // Limit on the number of consecutive punctuation characters. |
| string punctuation_limit_; |
| // The maximum number of digits allowed in a digit-separated block. As we |
| // allow all digits in a single block, this should be set high enough to |
| // accommodate the entire national number and the international country code. |
| int digit_block_limit_; |
| // Limit on the number of blocks separated by punctuation. Uses |
| // kDigitBlockLimit since some formats use spaces to separate each digit. |
| string block_limit_; |
| // A punctuation sequence allowing white space. |
| string punctuation_; |
| // A digits block without punctuation. |
| string digit_sequence_; |
| // Punctuation that may be at the start of a phone number - brackets and plus |
| // signs. |
| string lead_class_chars_; |
| // Same as lead_class_chars_, but enclosed as a character class. |
| string lead_class_; |
| // Extra helper strings that form part of pattern_. These are stored |
| // separately since StrCat has a limit of 12 args. |
| string opening_punctuation_; |
| string optional_extn_pattern_; |
| |
| public: |
| // We use two different reg-ex factories here for performance reasons. RE2 is |
| // much faster for smaller reg-ex patterns, but the main pattern cannot be |
| // handled by RE2 in an efficient way. |
| scoped_ptr<const AbstractRegExpFactory> regexp_factory_for_pattern_; |
| scoped_ptr<const AbstractRegExpFactory> regexp_factory_; |
| |
| // Matches strings that look like publication pages. Example: |
| // Computing Complete Answers to Queries in the Presence of Limited Access |
| // Patterns. Chen Li. VLDB J. 12(3): 211-227 (2003). |
| // |
| // The string "211-227 (2003)" is not a telephone number. |
| scoped_ptr<const RegExp> pub_pages_; |
| // Matches strings that look like dates using "/" as a separator. Examples: |
| // 3/10/2011, 31/10/96 or 08/31/95. |
| scoped_ptr<const RegExp> slash_separated_dates_; |
| // Matches timestamps. Examples: "2012-01-02 08:00". Note that the reg-ex does |
| // not include trailing ":\d\d" -- that is covered by time_stamps_suffix_. |
| scoped_ptr<const RegExp> time_stamps_; |
| scoped_ptr<const RegExp> time_stamps_suffix_; |
| // Pattern to check that brackets match. Opening brackets should be closed |
| // within a phone number. This also checks that there is something inside the |
| // brackets. Having no brackets at all is also fine. |
| scoped_ptr<const RegExp> matching_brackets_; |
| // Matches white-space, which may indicate the end of a phone number and the |
| // start of something else (such as a neighbouring zip-code). If white-space |
| // is found, continues to match all characters that are not typically used to |
| // start a phone number. |
| scoped_ptr<const RegExp> group_separator_; |
| scoped_ptr<const RegExp> capture_up_to_second_number_start_pattern_; |
| scoped_ptr<const RegExp> capturing_ascii_digits_pattern_; |
| // Compiled reg-ex representing lead_class_; |
| scoped_ptr<const RegExp> lead_class_pattern_; |
| // Phone number pattern allowing optional punctuation. |
| scoped_ptr<const RegExp> pattern_; |
| |
| PhoneNumberMatcherRegExps() |
| : opening_parens_("(\\[\xEF\xBC\x88\xEF\xBC\xBB" /* "(\\[（［" */), |
| closing_parens_(")\\]\xEF\xBC\x89\xEF\xBC\xBD" /* ")\\]）］" */), |
| non_parens_(StrCat("[^", opening_parens_, closing_parens_, "]")), |
| bracket_pair_limit_(Limit(0, 3)), |
| leading_maybe_matched_bracket_(StrCat( |
| "(?:[", opening_parens_, "])?", |
| "(?:", non_parens_, "+[", closing_parens_, "])?")), |
| bracket_pairs_(StrCat( |
| "(?:[", opening_parens_, "]", non_parens_, "+", |
| "[", closing_parens_, "])", bracket_pair_limit_)), |
| lead_limit_(Limit(0, 2)), |
| punctuation_limit_(Limit(0, 4)), |
| digit_block_limit_(PhoneNumberUtil::kMaxLengthForNsn + |
| PhoneNumberUtil::kMaxLengthCountryCode), |
| block_limit_(Limit(0, digit_block_limit_)), |
| punctuation_(StrCat("[", PhoneNumberUtil::kValidPunctuation, "]", |
| punctuation_limit_)), |
| digit_sequence_(StrCat("\\p{Nd}", Limit(1, digit_block_limit_))), |
| lead_class_chars_(StrCat(opening_parens_, PhoneNumberUtil::kPlusChars)), |
| lead_class_(StrCat("[", lead_class_chars_, "]")), |
| opening_punctuation_(StrCat("(?:", lead_class_, punctuation_, ")")), |
| optional_extn_pattern_(StrCat( |
| "(?i)(?:", |
| PhoneNumberUtil::GetInstance()->GetExtnPatternsForMatching(), |
| ")?")), |
| regexp_factory_for_pattern_(new ICURegExpFactory()), |
| #ifdef I18N_PHONENUMBERS_USE_RE2 |
| regexp_factory_(new RE2RegExpFactory()), |
| #else |
| regexp_factory_(new ICURegExpFactory()), |
| #endif // I18N_PHONENUMBERS_USE_RE2 |
| pub_pages_(regexp_factory_->CreateRegExp( |
| "\\d{1,5}-+\\d{1,5}\\s{0,4}\\(\\d{1,4}")), |
| slash_separated_dates_(regexp_factory_->CreateRegExp( |
| "(?:(?:[0-3]?\\d/[01]?\\d)|" |
| "(?:[01]?\\d/[0-3]?\\d))/(?:[12]\\d)?\\d{2}")), |
| time_stamps_(regexp_factory_->CreateRegExp( |
| "[12]\\d{3}[-/]?[01]\\d[-/]?[0-3]\\d [0-2]\\d$")), |
| time_stamps_suffix_(regexp_factory_->CreateRegExp(":[0-5]\\d")), |
| matching_brackets_(regexp_factory_->CreateRegExp( |
| StrCat(leading_maybe_matched_bracket_, non_parens_, "+", |
| bracket_pairs_, non_parens_, "*"))), |
| group_separator_(regexp_factory_->CreateRegExp( |
| StrCat("\\p{Z}", "[^", lead_class_chars_, "\\p{Nd}]*"))), |
| capture_up_to_second_number_start_pattern_( |
| regexp_factory_->CreateRegExp( |
| PhoneNumberUtil::kCaptureUpToSecondNumberStart)), |
| capturing_ascii_digits_pattern_( |
| regexp_factory_->CreateRegExp("(\\d+)")), |
| lead_class_pattern_(regexp_factory_->CreateRegExp(lead_class_)), |
| pattern_(regexp_factory_for_pattern_->CreateRegExp( |
| StrCat("(", opening_punctuation_, lead_limit_, |
| digit_sequence_, "(?:", punctuation_, digit_sequence_, ")", |
| block_limit_, optional_extn_pattern_, ")"))) { |
| } |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(PhoneNumberMatcherRegExps); |
| }; |
| |
| class AlternateFormats : public Singleton<AlternateFormats> { |
| public: |
| PhoneMetadataCollection format_data_; |
| |
| map<int, const PhoneMetadata*> calling_code_to_alternate_formats_map_; |
| |
| AlternateFormats() |
| : format_data_(), |
| calling_code_to_alternate_formats_map_() { |
| if (!LoadAlternateFormats(&format_data_)) { |
| LOG(DFATAL) << "Could not parse compiled-in metadata."; |
| return; |
| } |
| for (RepeatedPtrField<PhoneMetadata>::const_iterator it = |
| format_data_.metadata().begin(); |
| it != format_data_.metadata().end(); |
| ++it) { |
| calling_code_to_alternate_formats_map_.insert( |
| make_pair(it->country_code(), &*it)); |
| } |
| } |
| |
| const PhoneMetadata* GetAlternateFormatsForCountry(int country_calling_code) |
| const { |
| map<int, const PhoneMetadata*>::const_iterator it = |
| calling_code_to_alternate_formats_map_.find(country_calling_code); |
| if (it != calling_code_to_alternate_formats_map_.end()) { |
| return it->second; |
| } |
| return NULL; |
| } |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(AlternateFormats); |
| }; |
| |
| PhoneNumberMatcher::PhoneNumberMatcher(const PhoneNumberUtil& util, |
| const string& text, |
| const string& region_code, |
| PhoneNumberMatcher::Leniency leniency, |
| int max_tries) |
| : reg_exps_(PhoneNumberMatcherRegExps::GetInstance()), |
| alternate_formats_(AlternateFormats::GetInstance()), |
| phone_util_(util), |
| text_(text), |
| preferred_region_(region_code), |
| leniency_(leniency), |
| max_tries_(max_tries), |
| state_(NOT_READY), |
| last_match_(NULL), |
| search_index_(0) { |
| } |
| |
| PhoneNumberMatcher::PhoneNumberMatcher(const string& text, |
| const string& region_code) |
| : reg_exps_(PhoneNumberMatcherRegExps::GetInstance()), |
| alternate_formats_(NULL), // Not used. |
| phone_util_(*PhoneNumberUtil::GetInstance()), |
| text_(text), |
| preferred_region_(region_code), |
| leniency_(VALID), |
| max_tries_(numeric_limits<int>::max()), |
| state_(NOT_READY), |
| last_match_(NULL), |
| search_index_(0) { |
| } |
| |
| PhoneNumberMatcher::~PhoneNumberMatcher() { |
| } |
| |
| // static |
| bool PhoneNumberMatcher::IsLatinLetter(char32 letter) { |
| // Combining marks are a subset of non-spacing-mark. |
| if (!u_isalpha(letter) && (u_charType(letter) != U_NON_SPACING_MARK)) { |
| return false; |
| } |
| UBlockCode block = ublock_getCode(letter); |
| return ((block == UBLOCK_BASIC_LATIN) || |
| (block == UBLOCK_LATIN_1_SUPPLEMENT) || |
| (block == UBLOCK_LATIN_EXTENDED_A) || |
| (block == UBLOCK_LATIN_EXTENDED_ADDITIONAL) || |
| (block == UBLOCK_LATIN_EXTENDED_B) || |
| (block == UBLOCK_COMBINING_DIACRITICAL_MARKS)); |
| } |
| |
| bool PhoneNumberMatcher::ParseAndVerify(const string& candidate, int offset, |
| PhoneNumberMatch* match) { |
| DCHECK(match); |
| // Check the candidate doesn't contain any formatting which would indicate |
| // that it really isn't a phone number. |
| if (!reg_exps_->matching_brackets_->FullMatch(candidate)) { |
| return false; |
| } |
| |
| // If leniency is set to VALID or stricter, we also want to skip numbers that |
| // are surrounded by Latin alphabetic characters, to skip cases like |
| // abc8005001234 or 8005001234def. |
| if (leniency_ >= VALID) { |
| // If the candidate is not at the start of the text, and does not start with |
| // phone-number punctuation, check the previous character. |
| scoped_ptr<RegExpInput> candidate_input( |
| reg_exps_->regexp_factory_->CreateInput(candidate)); |
| if (offset > 0 && |
| !reg_exps_->lead_class_pattern_->Consume(candidate_input.get())) { |
| char32 previous_char; |
| const char* previous_char_ptr = |
| EncodingUtils::BackUpOneUTF8Character(text_.c_str(), |
| text_.c_str() + offset); |
| EncodingUtils::DecodeUTF8Char(previous_char_ptr, &previous_char); |
| // We return false if it is a latin letter or an invalid punctuation |
| // symbol. |
| if (IsInvalidPunctuationSymbol(previous_char) || |
| IsLatinLetter(previous_char)) { |
| return false; |
| } |
| } |
| size_t lastCharIndex = offset + candidate.length(); |
| if (lastCharIndex < text_.length()) { |
| char32 next_char; |
| const char* next_char_ptr = |
| EncodingUtils::AdvanceOneUTF8Character( |
| text_.c_str() + lastCharIndex - 1); |
| EncodingUtils::DecodeUTF8Char(next_char_ptr, &next_char); |
| if (IsInvalidPunctuationSymbol(next_char) || IsLatinLetter(next_char)) { |
| return false; |
| } |
| } |
| } |
| |
| PhoneNumber number; |
| if (phone_util_.ParseAndKeepRawInput(candidate, preferred_region_, &number) != |
| PhoneNumberUtil::NO_PARSING_ERROR) { |
| return false; |
| } |
| if (VerifyAccordingToLeniency(leniency_, number, candidate)) { |
| match->set_start(offset); |
| match->set_raw_string(candidate); |
| // We used ParseAndKeepRawInput to create this number, but for now we don't |
| // return the extra values parsed. TODO: stop clearing all values here and |
| // switch all users over to using raw_input() rather than the raw_string() |
| // of PhoneNumberMatch. |
| number.clear_country_code_source(); |
| number.clear_preferred_domestic_carrier_code(); |
| number.clear_raw_input(); |
| match->set_number(number); |
| return true; |
| } |
| return false; |
| } |
| |
| // Helper method to replace the verification method for each enum in the Java |
| // version. |
| bool PhoneNumberMatcher::VerifyAccordingToLeniency( |
| Leniency leniency, const PhoneNumber& number, |
| const string& candidate) const { |
| switch (leniency) { |
| case PhoneNumberMatcher::POSSIBLE: |
| return phone_util_.IsPossibleNumber(number); |
| case PhoneNumberMatcher::VALID: |
| if (!phone_util_.IsValidNumber(number) || |
| !ContainsOnlyValidXChars(number, candidate, phone_util_)) { |
| return false; |
| } |
| return IsNationalPrefixPresentIfRequired(number); |
| case PhoneNumberMatcher::STRICT_GROUPING: { |
| if (!phone_util_.IsValidNumber(number) || |
| !ContainsOnlyValidXChars(number, candidate, phone_util_) || |
| ContainsMoreThanOneSlashInNationalNumber( |
| number, candidate, phone_util_) || |
| !IsNationalPrefixPresentIfRequired(number)) { |
| return false; |
| } |
| ResultCallback4<bool, const PhoneNumberUtil&, const PhoneNumber&, |
| const string&, const vector<string>&>* callback = |
| NewPermanentCallback(&AllNumberGroupsRemainGrouped); |
| bool is_valid = CheckNumberGroupingIsValid(number, candidate, callback); |
| delete(callback); |
| return is_valid; |
| } |
| case PhoneNumberMatcher::EXACT_GROUPING: { |
| if (!phone_util_.IsValidNumber(number) || |
| !ContainsOnlyValidXChars(number, candidate, phone_util_) || |
| ContainsMoreThanOneSlashInNationalNumber( |
| number, candidate, phone_util_) || |
| !IsNationalPrefixPresentIfRequired(number)) { |
| return false; |
| } |
| ResultCallback4<bool, const PhoneNumberUtil&, const PhoneNumber&, |
| const string&, const vector<string>&>* callback = |
| NewPermanentCallback( |
| this, &PhoneNumberMatcher::AllNumberGroupsAreExactlyPresent); |
| bool is_valid = CheckNumberGroupingIsValid(number, candidate, callback); |
| delete(callback); |
| return is_valid; |
| } |
| default: |
| LOG(ERROR) << "No implementation defined for verification for leniency " |
| << static_cast<int>(leniency); |
| return false; |
| } |
| } |
| |
| bool PhoneNumberMatcher::ExtractInnerMatch(const string& candidate, int offset, |
| PhoneNumberMatch* match) { |
| DCHECK(match); |
| // Try removing either the first or last "group" in the number and see if this |
| // gives a result. We consider white space to be a possible indication of |
| // the start or end of the phone number. |
| scoped_ptr<RegExpInput> candidate_input( |
| reg_exps_->regexp_factory_->CreateInput(candidate)); |
| if (reg_exps_->group_separator_->FindAndConsume(candidate_input.get(), |
| NULL)) { |
| // Try the first group by itself. |
| int group_start_index = |
| candidate.length() - candidate_input->ToString().length(); |
| string first_group_only = candidate.substr(0, group_start_index); |
| phone_util_.TrimUnwantedEndChars(&first_group_only); |
| bool success = ParseAndVerify(first_group_only, offset, match); |
| if (success) { |
| return true; |
| } |
| --max_tries_; |
| |
| // Try the rest of the candidate without the first group. |
| string without_first_group(candidate_input->ToString()); |
| phone_util_.TrimUnwantedEndChars(&without_first_group); |
| success = |
| ParseAndVerify(without_first_group, offset + group_start_index, match); |
| if (success) { |
| return true; |
| } |
| --max_tries_; |
| |
| if (max_tries_ > 0) { |
| while (reg_exps_->group_separator_->FindAndConsume(candidate_input.get(), |
| NULL)) { |
| // Find the last group. |
| } |
| int last_group_start = |
| candidate.length() - candidate_input->ToString().length(); |
| string without_last_group = candidate.substr(0, last_group_start); |
| phone_util_.TrimUnwantedEndChars(&without_last_group); |
| if (without_last_group == first_group_only) { |
| // If there are only two groups, then the group "without the last group" |
| // is the same as the first group. In these cases, we don't want to |
| // re-check the number group, so we exit already. |
| return false; |
| } |
| success = ParseAndVerify(without_last_group, offset, match); |
| if (success) { |
| return true; |
| } |
| --max_tries_; |
| } |
| } |
| return false; |
| } |
| |
| bool PhoneNumberMatcher::ExtractMatch(const string& candidate, int offset, |
| PhoneNumberMatch* match) { |
| DCHECK(match); |
| // Skip a match that is more likely a publication page reference or a date. |
| if (reg_exps_->pub_pages_->PartialMatch(candidate) || |
| reg_exps_->slash_separated_dates_->PartialMatch(candidate)) { |
| return false; |
| } |
| // Skip potential time-stamps. |
| if (reg_exps_->time_stamps_->PartialMatch(candidate)) { |
| scoped_ptr<RegExpInput> following_text( |
| reg_exps_->regexp_factory_->CreateInput( |
| text_.substr(offset + candidate.size()))); |
| if (reg_exps_->time_stamps_suffix_->Consume(following_text.get())) { |
| return false; |
| } |
| } |
| |
| // Try to come up with a valid match given the entire candidate. |
| if (ParseAndVerify(candidate, offset, match)) { |
| return true; |
| } |
| |
| // If that failed, try to find an "inner match" - there might be a phone |
| // number within this candidate. |
| return ExtractInnerMatch(candidate, offset, match); |
| } |
| |
| bool PhoneNumberMatcher::HasNext() { |
| if (state_ == NOT_READY) { |
| PhoneNumberMatch temp_match; |
| if (!Find(search_index_, &temp_match)) { |
| state_ = DONE; |
| } else { |
| last_match_.reset(new PhoneNumberMatch(temp_match.start(), |
| temp_match.raw_string(), |
| temp_match.number())); |
| search_index_ = last_match_->end(); |
| state_ = READY; |
| } |
| } |
| return state_ == READY; |
| } |
| |
| bool PhoneNumberMatcher::Next(PhoneNumberMatch* match) { |
| DCHECK(match); |
| // Check the state and find the next match as a side-effect if necessary. |
| if (!HasNext()) { |
| return false; |
| } |
| match->CopyFrom(*last_match_); |
| state_ = NOT_READY; |
| last_match_.reset(NULL); |
| return true; |
| } |
| |
| bool PhoneNumberMatcher::Find(int index, PhoneNumberMatch* match) { |
| DCHECK(match); |
| |
| scoped_ptr<RegExpInput> text( |
| reg_exps_->regexp_factory_for_pattern_->CreateInput(text_.substr(index))); |
| string candidate; |
| while ((max_tries_ > 0) && |
| reg_exps_->pattern_->FindAndConsume(text.get(), &candidate)) { |
| int start = text_.length() - text->ToString().length() - candidate.length(); |
| // Check for extra numbers at the end. |
| reg_exps_->capture_up_to_second_number_start_pattern_-> |
| PartialMatch(candidate, &candidate); |
| if (ExtractMatch(candidate, start, match)) { |
| return true; |
| } |
| |
| index = start + candidate.length(); |
| --max_tries_; |
| } |
| return false; |
| } |
| |
| bool PhoneNumberMatcher::CheckNumberGroupingIsValid( |
| const PhoneNumber& phone_number, |
| const string& candidate, |
| ResultCallback4<bool, const PhoneNumberUtil&, const PhoneNumber&, |
| const string&, const vector<string>&>* checker) const { |
| DCHECK(checker); |
| // TODO: Evaluate how this works for other locales (testing has been limited |
| // to NANPA regions) and optimise if necessary. |
| string normalized_candidate = |
| NormalizeUTF8::NormalizeDecimalDigits(candidate); |
| vector<string> formatted_number_groups; |
| GetNationalNumberGroups(phone_number, NULL, // Use default formatting pattern |
| &formatted_number_groups); |
| if (checker->Run(phone_util_, phone_number, normalized_candidate, |
| formatted_number_groups)) { |
| return true; |
| } |
| // If this didn't pass, see if there are any alternate formats, and try them |
| // instead. |
| const PhoneMetadata* alternate_formats = |
| alternate_formats_->GetAlternateFormatsForCountry( |
| phone_number.country_code()); |
| if (alternate_formats) { |
| for (RepeatedPtrField<NumberFormat>::const_iterator it = |
| alternate_formats->number_format().begin(); |
| it != alternate_formats->number_format().end(); ++it) { |
| formatted_number_groups.clear(); |
| GetNationalNumberGroups(phone_number, &*it, &formatted_number_groups); |
| if (checker->Run(phone_util_, phone_number, normalized_candidate, |
| formatted_number_groups)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| // Helper method to get the national-number part of a number, formatted without |
| // any national prefix, and return it as a set of digit blocks that would be |
| // formatted together. |
| void PhoneNumberMatcher::GetNationalNumberGroups( |
| const PhoneNumber& number, |
| const NumberFormat* formatting_pattern, |
| vector<string>* digit_blocks) const { |
| string rfc3966_format; |
| if (!formatting_pattern) { |
| // This will be in the format +CC-DG;ext=EXT where DG represents groups of |
| // digits. |
| phone_util_.Format(number, PhoneNumberUtil::RFC3966, &rfc3966_format); |
| // We remove the extension part from the formatted string before splitting |
| // it into different groups. |
| size_t end_index = rfc3966_format.find(';'); |
| if (end_index == string::npos) { |
| end_index = rfc3966_format.length(); |
| } |
| // The country-code will have a '-' following it. |
| size_t start_index = rfc3966_format.find('-') + 1; |
| SplitStringUsing(rfc3966_format.substr(start_index, |
| end_index - start_index), |
| "-", digit_blocks); |
| } else { |
| // We format the NSN only, and split that according to the separator. |
| string national_significant_number; |
| phone_util_.GetNationalSignificantNumber(number, |
| &national_significant_number); |
| phone_util_.FormatNsnUsingPattern(national_significant_number, |
| *formatting_pattern, |
| PhoneNumberUtil::RFC3966, |
| &rfc3966_format); |
| SplitStringUsing(rfc3966_format, "-", digit_blocks); |
| } |
| } |
| |
| bool PhoneNumberMatcher::IsNationalPrefixPresentIfRequired( |
| const PhoneNumber& number) const { |
| // First, check how we deduced the country code. If it was written in |
| // international format, then the national prefix is not required. |
| if (number.country_code_source() != PhoneNumber::FROM_DEFAULT_COUNTRY) { |
| return true; |
| } |
| string phone_number_region; |
| phone_util_.GetRegionCodeForCountryCode( |
| number.country_code(), &phone_number_region); |
| const PhoneMetadata* metadata = |
| phone_util_.GetMetadataForRegion(phone_number_region); |
| if (!metadata) { |
| return true; |
| } |
| // Check if a national prefix should be present when formatting this number. |
| string national_number; |
| phone_util_.GetNationalSignificantNumber(number, &national_number); |
| const NumberFormat* format_rule = |
| phone_util_.ChooseFormattingPatternForNumber(metadata->number_format(), |
| national_number); |
| // To do this, we check that a national prefix formatting rule was present and |
| // that it wasn't just the first-group symbol ($1) with punctuation. |
| if (format_rule && !format_rule->national_prefix_formatting_rule().empty()) { |
| if (format_rule->national_prefix_optional_when_formatting()) { |
| // The national-prefix is optional in these cases, so we don't need to |
| // check if it was present. |
| return true; |
| } |
| if (phone_util_.FormattingRuleHasFirstGroupOnly( |
| format_rule->national_prefix_formatting_rule())) { |
| // National Prefix not needed for this number. |
| return true; |
| } |
| // Normalize the remainder. |
| string raw_input_copy(number.raw_input()); |
| // Check if we found a national prefix and/or carrier code at the start of |
| // the raw input, and return the result. |
| phone_util_.NormalizeDigitsOnly(&raw_input_copy); |
| return phone_util_.MaybeStripNationalPrefixAndCarrierCode( |
| *metadata, |
| &raw_input_copy, |
| NULL); // Don't need to keep the stripped carrier code. |
| } |
| return true; |
| } |
| |
| bool PhoneNumberMatcher::AllNumberGroupsAreExactlyPresent( |
| const PhoneNumberUtil& util, |
| const PhoneNumber& phone_number, |
| const string& normalized_candidate, |
| const vector<string>& formatted_number_groups) const { |
| const scoped_ptr<RegExpInput> candidate_number( |
| reg_exps_->regexp_factory_->CreateInput(normalized_candidate)); |
| vector<string> candidate_groups; |
| string digit_block; |
| while (reg_exps_->capturing_ascii_digits_pattern_->FindAndConsume( |
| candidate_number.get(), |
| &digit_block)) { |
| candidate_groups.push_back(digit_block); |
| } |
| |
| // Set this to the last group, skipping it if the number has an extension. |
| int candidate_number_group_index = |
| phone_number.has_extension() ? candidate_groups.size() - 2 |
| : candidate_groups.size() - 1; |
| // First we check if the national significant number is formatted as a block. |
| // We use find and not equals, since the national significant number may be |
| // present with a prefix such as a national number prefix, or the country code |
| // itself. |
| string national_significant_number; |
| util.GetNationalSignificantNumber(phone_number, |
| &national_significant_number); |
| if (candidate_groups.size() == 1 || |
| candidate_groups.at(candidate_number_group_index).find( |
| national_significant_number) != string::npos) { |
| return true; |
| } |
| // Starting from the end, go through in reverse, excluding the first group, |
| // and check the candidate and number groups are the same. |
| for (int formatted_number_group_index = |
| (formatted_number_groups.size() - 1); |
| formatted_number_group_index > 0 && |
| candidate_number_group_index >= 0; |
| --formatted_number_group_index, --candidate_number_group_index) { |
| if (candidate_groups.at(candidate_number_group_index) != |
| formatted_number_groups.at(formatted_number_group_index)) { |
| return false; |
| } |
| } |
| // Now check the first group. There may be a national prefix at the start, so |
| // we only check that the candidate group ends with the formatted number |
| // group. |
| return (candidate_number_group_index >= 0 && |
| HasSuffixString(candidate_groups.at(candidate_number_group_index), |
| formatted_number_groups.at(0))); |
| } |
| |
| // static |
| bool PhoneNumberMatcher::ContainsMoreThanOneSlashInNationalNumber( |
| const PhoneNumber& number, |
| const string& candidate, |
| const PhoneNumberUtil& util) { |
| size_t first_slash_in_body = candidate.find('/'); |
| if (first_slash_in_body == string::npos) { |
| // No slashes, this is okay. |
| return false; |
| } |
| // Now look for a second one. |
| size_t second_slash_in_body = candidate.find('/', first_slash_in_body + 1); |
| if (second_slash_in_body == string::npos) { |
| // Only one slash, this is okay. |
| return false; |
| } |
| |
| // If the first slash is after the country calling code, this is permitted. |
| if (number.country_code_source() == PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN || |
| number.country_code_source() == |
| PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN) { |
| string normalized_country_code = |
| candidate.substr(0, first_slash_in_body); |
| util.NormalizeDigitsOnly(&normalized_country_code); |
| if (normalized_country_code == SimpleItoa(number.country_code())) { |
| // Any more slashes and this is illegal. |
| return candidate.find('/', second_slash_in_body + 1) != string::npos; |
| } |
| } |
| return true; |
| } |
| |
| } // namespace phonenumbers |
| } // namespace i18n |
