~ken-vandine/+junk/libphonenumber : revision 12

1

2

//

3

// Licensed under the Apache License, Version 2.0 (the "License");

4

// you may not use this file except in compliance with the License.

5

// You may obtain a copy of the License at

6

//

7

// http://www.apache.org/licenses/LICENSE-2.0

8

//

9

// Unless required by applicable law or agreed to in writing, software

10

// distributed under the License is distributed on an "AS IS" BASIS,

11

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

12

// See the License for the specific language governing permissions and

13

// limitations under the License.

14

15

// Author: Shaopeng Jia

16

// Open-sourced by: Philippe Liard

17

18

#include "phonenumbers/phonenumberutil.h"

19

20

#include <string.h>

21

#include <algorithm>

22

#include <cctype>

23

#include <iterator>

24

#include <map>

25

#include <utility>

26

#include <vector>

27

28

#include <google/protobuf/message_lite.h>

29

#include <unicode/uchar.h>

30

#include <unicode/utf8.h>

31

32

#include "phonenumbers/asyoutypeformatter.h"

33

#include "phonenumbers/base/basictypes.h"

34

#include "phonenumbers/base/logging.h"

35

#include "phonenumbers/base/memory/singleton.h"

36

#include "phonenumbers/default_logger.h"

37

#include "phonenumbers/encoding_utils.h"

38

#include "phonenumbers/metadata.h"

39

#include "phonenumbers/normalize_utf8.h"

40

#include "phonenumbers/phonemetadata.pb.h"

41

#include "phonenumbers/phonenumber.h"

42

#include "phonenumbers/phonenumber.pb.h"

43

#include "phonenumbers/regexp_adapter.h"

44

#include "phonenumbers/regexp_cache.h"

45

#include "phonenumbers/regexp_factory.h"

46

#include "phonenumbers/region_code.h"

47

#include "phonenumbers/stl_util.h"

48

#include "phonenumbers/stringutil.h"

49

#include "phonenumbers/utf/unicodetext.h"

50

#include "phonenumbers/utf/utf.h"

51

52

namespace i18n {

53

namespace phonenumbers {

54

55

using google::protobuf::RepeatedPtrField;

56

57

// static constants

58

const size_t PhoneNumberUtil::kMinLengthForNsn;

59

const size_t PhoneNumberUtil::kMaxLengthForNsn;

60

const size_t PhoneNumberUtil::kMaxLengthCountryCode;

61

const int PhoneNumberUtil::kNanpaCountryCode;

62

63

// static

64

const char PhoneNumberUtil::kPlusChars[] = "+\xEF\xBC\x8B"; /* "+＋" */

65

// To find out the unicode code-point of the characters below in vim, highlight

66

// the character and type 'ga'. Note that the - is used to express ranges of

67

// full-width punctuation below, as well as being present in the expression

68

// itself. In emacs, you can use M-x unicode-what to query information about the

69

// unicode character.

70

// static

71

const char PhoneNumberUtil::kValidPunctuation[] =

72

/* "-x‐-―−ー－-／ <U+200B><U+2060>　()（）［］.\\[\\]/~⁓∼" */

73

"-x\xE2\x80\x90-\xE2\x80\x95\xE2\x88\x92\xE3\x83\xBC\xEF\xBC\x8D-\xEF\xBC"

74

"\x8F \xC2\xA0\xC2\xAD\xE2\x80\x8B\xE2\x81\xA0\xE3\x80\x80()\xEF\xBC\x88"

75

"\xEF\xBC\x89\xEF\xBC\xBB\xEF\xBC\xBD.\\[\\]/~\xE2\x81\x93\xE2\x88\xBC";

76

77

// static

78

const char PhoneNumberUtil::kCaptureUpToSecondNumberStart[] = "(.*)[\\\\/] *x";

79

80

// static

81

const char PhoneNumberUtil::kRegionCodeForNonGeoEntity[] = "001";

82

83

namespace {

84

85

// The prefix that needs to be inserted in front of a Colombian landline

86

// number when dialed from a mobile phone in Colombia.

87

const char kColombiaMobileToFixedLinePrefix[] = "3";

88

89

// The kPlusSign signifies the international prefix.

90

const char kPlusSign[] = "+";

91

92

const char kStarSign[] = "*";

93

94

const char kRfc3966ExtnPrefix[] = ";ext=";

95

const char kRfc3966Prefix[] = "tel:";

96

const char kRfc3966PhoneContext[] = ";phone-context=";

97

const char kRfc3966IsdnSubaddress[] = ";isub=";

98

99

const char kDigits[] = "\\p{Nd}";

100

// We accept alpha characters in phone numbers, ASCII only. We store lower-case

101

// here only since our regular expressions are case-insensitive.

102

const char kValidAlpha[] = "a-z";

103

104

// Default extension prefix to use when formatting. This will be put in front of

105

// any extension component of the number, after the main national number is

106

// formatted. For example, if you wish the default extension formatting to be "

107

// extn: 3456", then you should specify " extn: " here as the default extension

108

// prefix. This can be overridden by region-specific preferences.

109

const char kDefaultExtnPrefix[] = " ext. ";

110

111

// One-character symbols that can be used to indicate an extension.

112

const char kSingleExtnSymbolsForMatching[] =

113

"x\xEF\xBD\x98#\xEF\xBC\x83~\xEF\xBD\x9E";

114

115

bool LoadCompiledInMetadata(PhoneMetadataCollection* metadata) {

116

if (!metadata->ParseFromArray(metadata_get(), metadata_size())) {

117

LOG(ERROR) << "Could not parse binary data.";

118

return false;

119

}

120

return true;

121

}

122

123

// Returns a pointer to the description inside the metadata of the appropriate

124

// type.

125

const PhoneNumberDesc* GetNumberDescByType(

126

const PhoneMetadata& metadata,

127

PhoneNumberUtil::PhoneNumberType type) {

128

switch (type) {

129

case PhoneNumberUtil::PREMIUM_RATE:

130

return &metadata.premium_rate();

131

case PhoneNumberUtil::TOLL_FREE:

132

return &metadata.toll_free();

133

case PhoneNumberUtil::MOBILE:

134

return &metadata.mobile();

135

case PhoneNumberUtil::FIXED_LINE:

136

case PhoneNumberUtil::FIXED_LINE_OR_MOBILE:

137

return &metadata.fixed_line();

138

case PhoneNumberUtil::SHARED_COST:

139

return &metadata.shared_cost();

140

case PhoneNumberUtil::VOIP:

141

return &metadata.voip();

142

case PhoneNumberUtil::PERSONAL_NUMBER:

143

return &metadata.personal_number();

144

case PhoneNumberUtil::PAGER:

145

return &metadata.pager();

146

case PhoneNumberUtil::UAN:

147

return &metadata.uan();

148

case PhoneNumberUtil::VOICEMAIL:

149

return &metadata.voicemail();

150

default:

151

return &metadata.general_desc();

152

}

153

}

154

155

// A helper function that is used by Format and FormatByPattern.

156

void PrefixNumberWithCountryCallingCode(

157

int country_calling_code,

158

PhoneNumberUtil::PhoneNumberFormat number_format,

159

string* formatted_number) {

160

switch (number_format) {

161

case PhoneNumberUtil::E164:

162

formatted_number->insert(0, StrCat(kPlusSign, country_calling_code));

163

return;

164

case PhoneNumberUtil::INTERNATIONAL:

165

formatted_number->insert(0, StrCat(kPlusSign, country_calling_code, " "));

166

return;

167

case PhoneNumberUtil::RFC3966:

168

formatted_number->insert(0, StrCat(kRfc3966Prefix, kPlusSign,

169

country_calling_code, "-"));

170

return;

171

case PhoneNumberUtil::NATIONAL:

172

default:

173

// Do nothing.

174

return;

175

}

176

}

177

178

// Returns true when one national number is the suffix of the other or both are

179

// the same.

180

bool IsNationalNumberSuffixOfTheOther(const PhoneNumber& first_number,

181

const PhoneNumber& second_number) {

182

const string& first_number_national_number =

183

SimpleItoa(static_cast<uint64>(first_number.national_number()));

184

const string& second_number_national_number =

185

SimpleItoa(static_cast<uint64>(second_number.national_number()));

186

// Note that HasSuffixString returns true if the numbers are equal.

187

return HasSuffixString(first_number_national_number,

188

second_number_national_number) ||

189

HasSuffixString(second_number_national_number,

190

first_number_national_number);

191

}

192

193

char32 ToUnicodeCodepoint(const char* unicode_char) {

194

char32 codepoint;

195

EncodingUtils::DecodeUTF8Char(unicode_char, &codepoint);

196

return codepoint;

197

}

198

199

// Helper initialiser method to create the regular-expression pattern to match

200

// extensions, allowing the one-codepoint extension symbols provided by

201

// single_extn_symbols.

202

// Note that there are currently three capturing groups for the extension itself

203

// - if this number is changed, MaybeStripExtension needs to be updated.

204

string CreateExtnPattern(const string& single_extn_symbols) {

205

static const string capturing_extn_digits = StrCat("([", kDigits, "]{1,7})");

206

// The first regular expression covers RFC 3966 format, where the extension is

207

// added using ";ext=". The second more generic one starts with optional white

208

// space and ends with an optional full stop (.), followed by zero or more

209

// spaces/tabs and then the numbers themselves. The third one covers the

210

// special case of American numbers where the extension is written with a hash

211

// at the end, such as "- 503#".

212

// Note that the only capturing groups should be around the digits that you

213

// want to capture as part of the extension, or else parsing will fail!

214

// Canonical-equivalence doesn't seem to be an option with RE2, so we allow

215

// two options for representing the ó - the character itself, and one in the

216

// unicode decomposed form with the combining acute accent.

217

return (StrCat(

218

kRfc3966ExtnPrefix, capturing_extn_digits, "|"

219

/* "[ \\t,]*(?:e?xt(?:ensi(?:ó?|ó))?n?|ｅ?ｘｔｎ?|single_extn_symbols|"

220

"int|ｉｎｔ|anexo)"

221

"[:\\.．]?[ \\t,-]*", capturing_extn_digits, "#?|" */

222

"[ \xC2\xA0\\t,]*(?:e?xt(?:ensi(?:o\xCC\x81?|\xC3\xB3))?n?|"

223

"(?:\xEF\xBD\x85)?\xEF\xBD\x98\xEF\xBD\x94(?:\xEF\xBD\x8E)?|"

224

"[", single_extn_symbols, "]|int|"

225

"\xEF\xBD\x89\xEF\xBD\x8E\xEF\xBD\x94|anexo)"

226

"[:\\.\xEF\xBC\x8E]?[ \xC2\xA0\\t,-]*", capturing_extn_digits,

227

"#?|[- ]+([", kDigits, "]{1,5})#"));

228

}

229

230

// Normalizes a string of characters representing a phone number by replacing

231

// all characters found in the accompanying map with the values therein, and

232

// stripping all other characters if remove_non_matches is true.

233

// Parameters:

234

// number - a pointer to a string of characters representing a phone number to

235

// be normalized.

236

// normalization_replacements - a mapping of characters to what they should be

237

// replaced by in the normalized version of the phone number

238

// remove_non_matches - indicates whether characters that are not able to be

239

// replaced should be stripped from the number. If this is false, they will be

240

// left unchanged in the number.

241

void NormalizeHelper(const map<char32, char>& normalization_replacements,

242

bool remove_non_matches,

243

string* number) {

244

DCHECK(number);

245

UnicodeText number_as_unicode;

246

number_as_unicode.PointToUTF8(number->data(), number->size());

247

string normalized_number;

248

char unicode_char[5];

249

for (UnicodeText::const_iterator it = number_as_unicode.begin();

250

it != number_as_unicode.end();

251

++it) {

252

map<char32, char>::const_iterator found_glyph_pair =

253

normalization_replacements.find(*it);

254

if (found_glyph_pair != normalization_replacements.end()) {

255

normalized_number.push_back(found_glyph_pair->second);

256

} else if (!remove_non_matches) {

257

// Find out how long this unicode char is so we can append it all.

258

int char_len = it.get_utf8(unicode_char);

259

normalized_number.append(unicode_char, char_len);

260

}

261

// If neither of the above are true, we remove this character.

262

}

263

number->assign(normalized_number);

264

}

265

266

PhoneNumberUtil::ValidationResult TestNumberLengthAgainstPattern(

267

const RegExp& number_pattern, const string& number) {

268

string extracted_number;

269

if (number_pattern.FullMatch(number, &extracted_number)) {

270

return PhoneNumberUtil::IS_POSSIBLE;

271

}

272

if (number_pattern.PartialMatch(number, &extracted_number)) {

273

return PhoneNumberUtil::TOO_LONG;

274

} else {

275

return PhoneNumberUtil::TOO_SHORT;

276

}

277

}

278

279

} // namespace

280

281

void PhoneNumberUtil::SetLogger(Logger* logger) {

282

logger_.reset(logger);

283

Logger::set_logger_impl(logger_.get());

284

}

285

286

class PhoneNumberRegExpsAndMappings {

287

private:

288

void InitializeMapsAndSets() {

289

diallable_char_mappings_.insert(std::make_pair('+', '+'));

290

diallable_char_mappings_.insert(std::make_pair('*', '*'));

291

// Here we insert all punctuation symbols that we wish to respect when

292

// formatting alpha numbers, as they show the intended number groupings.

293