JAVA: Update to v3.4. Fixes issues 32 and 15.

java/release_notes.txt

@@ -1,3 +1,13 @@
+May 9th, 2011
+* Code changes:
+ - Fixed potential for a null-ptr exception in getExampleNumber
+ - Potential speed improvement with replacement of StringBuffer with StringBuilder
+* Metadata changes
+ - Changed way that international formats are specified to make it easier to do so
+ - New countries: AX, CC, CX, WF
+ - Updates: AM, AR, AU, AW, CN, CO, CR, DM, EC, ET, FI, FJ, GH, IN, JP, KE, KM,
+   KN, LR, MD, MQ, MX, NP, PH, SC, SE, SM, SN, SY, UG, US, VC, VI, ZM
+
 Apr 26th, 2011
 * Code changes:
  - Improved PhoneNumberMatcher for cases with other numbers before or after the phone number.

java/resources/com/google/i18n/phonenumbers/BuildMetadataFromXml.java

@@ -80,7 +80,7 @@ public class BuildMetadataFromXml {
       String regionCode = metadata.getId();
       int countryCode = metadata.getCountryCode();
       if (countryCodeToRegionCodeMap.containsKey(countryCode)) {
-        if (metadata.getMainCountryForCode()) {
+        if (metadata.isMainCountryForCode()) {
           countryCodeToRegionCodeMap.get(countryCode).add(0, regionCode);
         } else {
           countryCodeToRegionCodeMap.get(countryCode).add(regionCode);
@@ -160,11 +160,14 @@ public class BuildMetadataFromXml {
 
     // Extract availableFormats
     NodeList numberFormatElements = element.getElementsByTagName("numberFormat");
+    boolean hasExplicitIntlFormatDefined = false;
+
     int numOfFormatElements = numberFormatElements.getLength();
     if (numOfFormatElements > 0) {
       for (int i = 0; i < numOfFormatElements; i++) {
         Element numberFormatElement = (Element) numberFormatElements.item(i);
         NumberFormat format = new NumberFormat();
+
         if (numberFormatElement.hasAttribute("nationalPrefixFormattingRule")) {
           format.setNationalPrefixFormattingRule(
               getNationalPrefixFormattingRuleFromElement(numberFormatElement, nationalPrefix));
@@ -178,8 +181,11 @@ public class BuildMetadataFromXml {
         } else {
           format.setDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
         }
+
+        // Extract the pattern for the national format.
         setLeadingDigitsPatterns(numberFormatElement, format);
         format.setPattern(validateRE(numberFormatElement.getAttribute("pattern")));
+
         NodeList formatPattern = numberFormatElement.getElementsByTagName("format");
         if (formatPattern.getLength() != 1) {
           LOGGER.log(Level.SEVERE,
@@ -187,35 +193,46 @@ public class BuildMetadataFromXml {
           throw new RuntimeException("Invalid number of format patterns for country: " +
                                      regionCode);
         }
-        format.setFormat(formatPattern.item(0).getFirstChild().getNodeValue());
+        String nationalFormat = formatPattern.item(0).getFirstChild().getNodeValue();
+        format.setFormat(nationalFormat);
         metadata.addNumberFormat(format);
-      }
-    }
 
-    NodeList intlNumberFormatElements = element.getElementsByTagName("intlNumberFormat");
-    int numOfIntlFormatElements = intlNumberFormatElements.getLength();
-    if (numOfIntlFormatElements > 0) {
-      for (int i = 0; i < numOfIntlFormatElements; i++) {
-        Element numberFormatElement = (Element) intlNumberFormatElements.item(i);
-        NumberFormat format = new NumberFormat();
-        setLeadingDigitsPatterns(numberFormatElement, format);
-        format.setPattern(validateRE(numberFormatElement.getAttribute("pattern")));
-        NodeList formatPattern = numberFormatElement.getElementsByTagName("format");
-        if (formatPattern.getLength() != 1) {
+        // Extract the pattern for international format. If there is no intlFormat, default to
+        // using the national format. If the intlFormat is set to "NA" the intlFormat should be
+        // ignored.
+        NumberFormat intlFormat = new NumberFormat();
+        setLeadingDigitsPatterns(numberFormatElement, intlFormat);
+        intlFormat.setPattern(numberFormatElement.getAttribute("pattern"));
+        NodeList intlFormatPattern = numberFormatElement.getElementsByTagName("intlFormat");
+
+        if (intlFormatPattern.getLength() > 1) {
           LOGGER.log(Level.SEVERE,
-                     "Only one format pattern for a numberFormat element should be defined.");
-          throw new RuntimeException("Invalid number of format patterns for country: " +
+                     "A maximum of one intlFormat pattern for a numberFormat element should be " +
+                     "defined.");
+          throw new RuntimeException("Invalid number of intlFormat patterns for country: " +
                                      regionCode);
-        }
-        format.setFormat(validateRE(formatPattern.item(0).getFirstChild().getNodeValue()));
-        if (numberFormatElement.hasAttribute("carrierCodeFormattingRule")) {
-          format.setDomesticCarrierCodeFormattingRule(validateRE(
-              getDomesticCarrierCodeFormattingRuleFromElement(numberFormatElement,
-                                                              nationalPrefix)));
+        } else if (intlFormatPattern.getLength() == 0) {
+          // Default to use the same as the national pattern if none is defined.
+          intlFormat.setFormat(nationalFormat);
         } else {
-          format.setDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
+           String intlFormatPatternValue =
+               intlFormatPattern.item(0).getFirstChild().getNodeValue();
+           if (!intlFormatPatternValue.equals("NA")) {
+             intlFormat.setFormat(intlFormatPatternValue);
+           }
+           hasExplicitIntlFormatDefined = true;
         }
-        metadata.addIntlNumberFormat(format);
+
+        if (intlFormat.hasFormat()) {
+          metadata.addIntlNumberFormat(intlFormat);
+        }
+      }
+      // Only a small number of regions need to specify the intlFormats in the xml. For the majority
+      // of countries the intlNumberFormat metadata is an exact copy of the national NumberFormat
+      // metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that
+      // actually differ in some way to the national formats.
+      if (!hasExplicitIntlFormatDefined) {
+        metadata.clearIntlNumberFormat();
       }
     }
 

java/resources/com/google/i18n/phonenumbers/BuildMetadataJsonFromXml.java

@@ -334,7 +334,7 @@ public class BuildMetadataJsonFromXml {
     // required PhoneNumberDesc pager = 21;
     toJsArray(metadata.getPager(), jsArrayBuilder);
     // optional bool main_country_for_code = 22 [default=false];
-    if (metadata.getMainCountryForCode()) {
+    if (metadata.isMainCountryForCode()) {
       jsArrayBuilder.append(1);
     } else {
       jsArrayBuilder.append(null);

java/src/com/google/i18n/phonenumbers/CountryCodeToRegionCodeMap.java

@@ -181,8 +181,10 @@ public class CountryCodeToRegionCodeMap {
     listWithRegionCode.add("MY");
     countryCodeToRegionCodeMap.put(60, listWithRegionCode);
 
-    listWithRegionCode = new ArrayList<String>(1);
+    listWithRegionCode = new ArrayList<String>(3);
     listWithRegionCode.add("AU");
+    listWithRegionCode.add("CC");
+    listWithRegionCode.add("CX");
     countryCodeToRegionCodeMap.put(61, listWithRegionCode);
 
     listWithRegionCode = new ArrayList<String>(1);
@@ -515,8 +517,9 @@ public class CountryCodeToRegionCodeMap {
     listWithRegionCode.add("CY");
     countryCodeToRegionCodeMap.put(357, listWithRegionCode);
 
-    listWithRegionCode = new ArrayList<String>(1);
+    listWithRegionCode = new ArrayList<String>(2);
     listWithRegionCode.add("FI");
+    listWithRegionCode.add("AX");
     countryCodeToRegionCodeMap.put(358, listWithRegionCode);
 
     listWithRegionCode = new ArrayList<String>(1);

java/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java

@@ -320,7 +320,12 @@ public class PhoneNumberUtil {
       Pattern.compile(VALID_PHONE_NUMBER + "(?:" + KNOWN_EXTN_PATTERNS + ")?", REGEX_FLAGS);
 
   private static final Pattern NON_DIGITS_PATTERN = Pattern.compile("(\\D+)");
-  private static final Pattern FIRST_GROUP_PATTERN = Pattern.compile("(\\$1)");
+
+  // The FIRST_GROUP_PATTERN was originally set to $1 but there are some countries for which the
+  // first group is not used in the national pattern (e.g. Argentina) so the $1 group does not match
+  // correctly.  Therefore, we use \d, so that the first group actually used in the pattern will be
+  // matched.
+  private static final Pattern FIRST_GROUP_PATTERN = Pattern.compile("(\\$\\d)");
   private static final Pattern NP_PATTERN = Pattern.compile("\\$NP");
   private static final Pattern FG_PATTERN = Pattern.compile("\\$FG");
   private static final Pattern CC_PATTERN = Pattern.compile("\\$CC");
@@ -639,6 +644,7 @@ public class PhoneNumberUtil {
    * country calling code when the number is formatted in the international format, if there is a
    * subscriber number part that follows. An example of how this could be used:
    *
+   * <pre>
    * PhoneNumberUtil phoneUtil = PhoneNumberUtil.getInstance();
    * PhoneNumber number = phoneUtil.parse("18002530000", "US");
    * String nationalSignificantNumber = phoneUtil.getNationalSignificantNumber(number);
@@ -657,7 +663,7 @@ public class PhoneNumberUtil {
    * </pre>
    *
    * Refer to the unittests to see the difference between this function and
-   * {@link getLengthOfGeographicalAreaCode()}.
+   * {@link #getLengthOfGeographicalAreaCode()}.
    *
    * @param number  the PhoneNumber object for which clients want to know the length of the NDC.
    * @return  the length of NDC of the PhoneNumber object passed in.
@@ -1312,6 +1318,11 @@ public class PhoneNumberUtil {
    *     does not contain such information.
    */
   public PhoneNumber getExampleNumberForType(String regionCode, PhoneNumberType type) {
+    // Check the region code is valid.
+    if (!isValidRegionCode(regionCode)) {
+      LOGGER.log(Level.WARNING, "Invalid or unknown region code provided.");
+      return null;
+    }
     PhoneNumberDesc desc = getNumberDescByType(getMetadataForRegion(regionCode), type);
     try {
       if (desc.hasExampleNumber()) {
@@ -1567,9 +1578,6 @@ public class PhoneNumberUtil {
       return 0;
     }
     PhoneMetadata metadata = getMetadataForRegion(regionCode);
-    if (metadata == null) {
-      return 0;
-    }
     return metadata.getCountryCode();
   }
 
@@ -1594,10 +1602,6 @@ public class PhoneNumberUtil {
       return null;
     }
     PhoneMetadata metadata = getMetadataForRegion(regionCode);
-    if (metadata == null) {
-      LOGGER.log(Level.SEVERE, "Unsupported region code provided.");
-      return null;
-    }
     String nationalPrefix = metadata.getNationalPrefix();
     // If no national prefix was found, we return null.
     if (nationalPrefix.length() == 0) {

java/src/com/google/i18n/phonenumbers/Phonemetadata.java

@@ -578,12 +578,16 @@ public final class Phonemetadata {
       intlNumberFormat_.add(value);
       return this;
     }
+    public PhoneMetadata clearIntlNumberFormat() {
+      intlNumberFormat_.clear();
+      return this;
+    }
 
     // optional bool main_country_for_code = 22 [default = false];
     private boolean hasMainCountryForCode;
     private boolean mainCountryForCode_ = false;
     public boolean hasMainCountryForCode() { return hasMainCountryForCode; }
-    public boolean getMainCountryForCode() { return mainCountryForCode_; }
+    public boolean isMainCountryForCode() { return mainCountryForCode_; }
     public PhoneMetadata setMainCountryForCode(boolean value) {
       hasMainCountryForCode = true;
       mainCountryForCode_ = value;

java/test/com/google/i18n/phonenumbers/AsYouTypeFormatterTest.java

@@ -460,8 +460,7 @@ public class AsYouTypeFormatterTest extends TestCase {
     assertEquals("+54 9", formatter.inputDigit('9'));
     assertEquals("+54 91", formatter.inputDigit('1'));
     assertEquals("+54 9 11", formatter.inputDigit('1'));
-    assertEquals("+54 9 11 2",
-                 formatter.inputDigit('2'));
+    assertEquals("+54 9 11 2", formatter.inputDigit('2'));
     assertEquals("+54 9 11 23", formatter.inputDigit('3'));
     assertEquals("+54 9 11 231", formatter.inputDigit('1'));
     assertEquals("+54 9 11 2312", formatter.inputDigit('2'));
@@ -561,6 +560,91 @@ public class AsYouTypeFormatterTest extends TestCase {
     assertEquals("011-9876-7890", formatter.inputDigit('0'));
   }
 
+  public void testAYTF_MX() {
+    AsYouTypeFormatter formatter = phoneUtil.getAsYouTypeFormatter("MX");
+
+    // +52 800 123 4567
+    assertEquals("+", formatter.inputDigit('+'));
+    assertEquals("+5", formatter.inputDigit('5'));
+    assertEquals("+52 ", formatter.inputDigit('2'));
+    assertEquals("+52 8", formatter.inputDigit('8'));
+    assertEquals("+52 80", formatter.inputDigit('0'));
+    assertEquals("+52 800", formatter.inputDigit('0'));
+    assertEquals("+52 800 1", formatter.inputDigit('1'));
+    assertEquals("+52 800 12", formatter.inputDigit('2'));
+    assertEquals("+52 800 123", formatter.inputDigit('3'));
+    assertEquals("+52 800 123 4", formatter.inputDigit('4'));
+    assertEquals("+52 800 123 45", formatter.inputDigit('5'));
+    assertEquals("+52 800 123 456", formatter.inputDigit('6'));
+    assertEquals("+52 800 123 4567", formatter.inputDigit('7'));
+
+    // +52 55 1234 5678
+    formatter.clear();
+    assertEquals("+", formatter.inputDigit('+'));
+    assertEquals("+5", formatter.inputDigit('5'));
+    assertEquals("+52 ", formatter.inputDigit('2'));
+    assertEquals("+52 5", formatter.inputDigit('5'));
+    assertEquals("+52 55", formatter.inputDigit('5'));
+    assertEquals("+52 55 1", formatter.inputDigit('1'));
+    assertEquals("+52 55 12", formatter.inputDigit('2'));
+    assertEquals("+52 55 123", formatter.inputDigit('3'));
+    assertEquals("+52 55 1234", formatter.inputDigit('4'));
+    assertEquals("+52 55 1234 5", formatter.inputDigit('5'));
+    assertEquals("+52 55 1234 56", formatter.inputDigit('6'));
+    assertEquals("+52 55 1234 567", formatter.inputDigit('7'));
+    assertEquals("+52 55 1234 5678", formatter.inputDigit('8'));
+
+    // +52 212 345 6789
+    formatter.clear();
+    assertEquals("+", formatter.inputDigit('+'));
+    assertEquals("+5", formatter.inputDigit('5'));
+    assertEquals("+52 ", formatter.inputDigit('2'));
+    assertEquals("+52 2", formatter.inputDigit('2'));
+    assertEquals("+52 21", formatter.inputDigit('1'));
+    assertEquals("+52 212", formatter.inputDigit('2'));
+    assertEquals("+52 212 3", formatter.inputDigit('3'));
+    assertEquals("+52 212 34", formatter.inputDigit('4'));
+    assertEquals("+52 212 345", formatter.inputDigit('5'));
+    assertEquals("+52 212 345 6", formatter.inputDigit('6'));
+    assertEquals("+52 212 345 67", formatter.inputDigit('7'));
+    assertEquals("+52 212 345 678", formatter.inputDigit('8'));
+    assertEquals("+52 212 345 6789", formatter.inputDigit('9'));
+
+    // +52 1 55 1234 5678
+    formatter.clear();
+    assertEquals("+", formatter.inputDigit('+'));
+    assertEquals("+5", formatter.inputDigit('5'));
+    assertEquals("+52 ", formatter.inputDigit('2'));
+    assertEquals("+52 1", formatter.inputDigit('1'));
+    assertEquals("+52 15", formatter.inputDigit('5'));
+    assertEquals("+52 1 55", formatter.inputDigit('5'));
+    assertEquals("+52 1 55 1", formatter.inputDigit('1'));
+    assertEquals("+52 1 55 12", formatter.inputDigit('2'));
+    assertEquals("+52 1 55 123", formatter.inputDigit('3'));
+    assertEquals("+52 1 55 1234", formatter.inputDigit('4'));
+    assertEquals("+52 1 55 1234 5", formatter.inputDigit('5'));
+    assertEquals("+52 1 55 1234 56", formatter.inputDigit('6'));
+    assertEquals("+52 1 55 1234 567", formatter.inputDigit('7'));
+    assertEquals("+52 1 55 1234 5678", formatter.inputDigit('8'));
+
+    // +52 1 541 234 5678
+    formatter.clear();
+    assertEquals("+", formatter.inputDigit('+'));
+    assertEquals("+5", formatter.inputDigit('5'));
+    assertEquals("+52 ", formatter.inputDigit('2'));
+    assertEquals("+52 1", formatter.inputDigit('1'));
+    assertEquals("+52 15", formatter.inputDigit('5'));
+    assertEquals("+52 1 54", formatter.inputDigit('4'));
+    assertEquals("+52 1 541", formatter.inputDigit('1'));
+    assertEquals("+52 1 541 2", formatter.inputDigit('2'));
+    assertEquals("+52 1 541 23", formatter.inputDigit('3'));
+    assertEquals("+52 1 541 234", formatter.inputDigit('4'));
+    assertEquals("+52 1 541 234 5", formatter.inputDigit('5'));
+    assertEquals("+52 1 541 234 56", formatter.inputDigit('6'));
+    assertEquals("+52 1 541 234 567", formatter.inputDigit('7'));
+    assertEquals("+52 1 541 234 5678", formatter.inputDigit('8'));
+  }
+
   public void testAYTFMultipleLeadingDigitPatterns() {
     // +81 50 2345 6789
     AsYouTypeFormatter formatter = phoneUtil.getAsYouTypeFormatter("JP");

java/test/com/google/i18n/phonenumbers/PhoneNumberMatcherTest.java

@@ -28,7 +28,6 @@ import java.util.NoSuchElementException;
 
 /**
  * Tests for {@link PhoneNumberMatcher}. This only tests basic functionality based on test metadata.
- * See {@link PhoneNumberMatcherRegressionTest} for regression tests.
  *
  * @author Tom Hofmann
  * @see PhoneNumberUtilTest {@link PhoneNumberUtilTest} for the origin of the test data

java/test/com/google/i18n/phonenumbers/PhoneNumberUtilTest.java

@@ -71,6 +71,15 @@ public class PhoneNumberUtilTest extends TestCase {
   private static final PhoneNumber IT_NUMBER =
       new PhoneNumber().setCountryCode(39).setNationalNumber(236618300L).
       setItalianLeadingZero(true);
+  // Numbers to test the formatting rules from Mexico.
+  private static final PhoneNumber MX_MOBILE1 =
+      new PhoneNumber().setCountryCode(52).setNationalNumber(12345678900L);
+  private static final PhoneNumber MX_MOBILE2 =
+      new PhoneNumber().setCountryCode(52).setNationalNumber(15512345678L);
+  private static final PhoneNumber MX_NUMBER1 =
+      new PhoneNumber().setCountryCode(52).setNationalNumber(3312345678L);
+  private static final PhoneNumber MX_NUMBER2 =
+      new PhoneNumber().setCountryCode(52).setNationalNumber(8211234567L);
   private static final PhoneNumber NZ_NUMBER =
       new PhoneNumber().setCountryCode(64).setNationalNumber(33316005L);
   private static final PhoneNumber SG_NUMBER =
@@ -177,8 +186,8 @@ public class PhoneNumberUtilTest extends TestCase {
     assertEquals("0", metadata.getNationalPrefix());
     assertEquals("0(?:(11|343|3715)15)?", metadata.getNationalPrefixForParsing());
     assertEquals("9$1", metadata.getNationalPrefixTransformRule());
-    assertEquals("$1 15 $2-$3", metadata.getNumberFormat(2).getFormat());
-    assertEquals("9(\\d{4})(\\d{2})(\\d{4})",
+    assertEquals("$2 15 $3-$4", metadata.getNumberFormat(2).getFormat());
+    assertEquals("(9)(\\d{4})(\\d{2})(\\d{4})",
                  metadata.getNumberFormat(3).getPattern());
     assertEquals("(9)(\\d{4})(\\d{2})(\\d{4})",
                  metadata.getIntlNumberFormat(3).getPattern());
@@ -276,6 +285,9 @@ public class PhoneNumberUtilTest extends TestCase {
                                                     PhoneNumberUtil.PhoneNumberType.FIXED_LINE));
     assertNotNull(phoneUtil.getExampleNumberForType(RegionCode.US,
                                                     PhoneNumberUtil.PhoneNumberType.MOBILE));
+    // CS is an invalid region, so we have no data for it.
+    assertNull(phoneUtil.getExampleNumberForType(RegionCode.CS,
+                                                 PhoneNumberUtil.PhoneNumberType.MOBILE));
   }
 
   public void testNormaliseRemovePunctuation() {
@@ -409,6 +421,26 @@ public class PhoneNumberUtilTest extends TestCase {
     assertEquals("+5491187654321", phoneUtil.format(AR_MOBILE, PhoneNumberFormat.E164));
   }
 
+  public void testFormatMXNumber() {
+    assertEquals("045 234 567 8900", phoneUtil.format(MX_MOBILE1, PhoneNumberFormat.NATIONAL));
+    assertEquals("+52 1 234 567 8900", phoneUtil.format(
+        MX_MOBILE1, PhoneNumberFormat.INTERNATIONAL));
+    assertEquals("+5212345678900", phoneUtil.format(MX_MOBILE1, PhoneNumberFormat.E164));
+
+    assertEquals("045 55 1234 5678", phoneUtil.format(MX_MOBILE2, PhoneNumberFormat.NATIONAL));
+    assertEquals("+52 1 55 1234 5678", phoneUtil.format(
+        MX_MOBILE2, PhoneNumberFormat.INTERNATIONAL));
+    assertEquals("+5215512345678", phoneUtil.format(MX_MOBILE2, PhoneNumberFormat.E164));
+
+    assertEquals("01 33 1234 5678", phoneUtil.format(MX_NUMBER1, PhoneNumberFormat.NATIONAL));
+    assertEquals("+52 33 1234 5678", phoneUtil.format(MX_NUMBER1, PhoneNumberFormat.INTERNATIONAL));
+    assertEquals("+523312345678", phoneUtil.format(MX_NUMBER1, PhoneNumberFormat.E164));
+
+    assertEquals("01 821 123 4567", phoneUtil.format(MX_NUMBER2, PhoneNumberFormat.NATIONAL));
+    assertEquals("+52 821 123 4567", phoneUtil.format(MX_NUMBER2, PhoneNumberFormat.INTERNATIONAL));
+    assertEquals("+528211234567", phoneUtil.format(MX_NUMBER2, PhoneNumberFormat.E164));
+  }
+
   public void testFormatOutOfCountryCallingNumber() {
     assertEquals("00 1 900 253 0000",
                  phoneUtil.formatOutOfCountryCallingNumber(US_PREMIUM, RegionCode.DE));

resources/PhoneNumberMetaDataForTesting.xml

@@ -17,7 +17,7 @@
      MetaData on Phone Number Plan and formatting rules. This file is used
      solely for the purpose of unittesting, so data in this file is not
      necessarily consistent with that of
-     ../src/PhoneNumberMetaData.xml
+     ../resources/PhoneNumberMetaData.xml
 -->
 
 <phoneNumberMetadata>
@@ -67,39 +67,21 @@
           <leadingDigits>1[02-9]|[23]</leadingDigits>
           <format>$1 $2-$3</format>
         </numberFormat>
-        <numberFormat pattern="9(11)(\d{4})(\d{4})">
+        <numberFormat pattern="(9)(11)(\d{4})(\d{4})">
           <leadingDigits>911</leadingDigits>
-          <format>$1 15 $2-$3</format>
+          <format>$2 15 $3-$4</format>
+          <intlFormat>$1 $2 $3 $4</intlFormat>
         </numberFormat>
-        <numberFormat pattern="9(\d{4})(\d{2})(\d{4})"
+        <numberFormat pattern="(9)(\d{4})(\d{2})(\d{4})"
           carrierCodeFormattingRule="$NP$FG $CC">
           <leadingDigits>9(?:1[02-9]|[23])</leadingDigits>
-          <format>$1 $2-$3</format>
+          <format>$2 $3-$4</format>
+          <intlFormat>$1 $2 $3 $4</intlFormat>
         </numberFormat>
         <numberFormat pattern="(\d{3})(\d{3})(\d{4})">
           <leadingDigits>[68]</leadingDigits>
           <format>$1-$2-$3</format>
         </numberFormat>
-        <intlNumberFormat pattern="(\d{2})(\d{4})(\d{4})">
-          <leadingDigits>11</leadingDigits>
-          <format>$1 $2-$3</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(\d{4})(\d{2})(\d{4})">
-          <leadingDigits>1[02-9]|[23]</leadingDigits>
-          <format>$1 $2-$3</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(9)(11)(\d{4})(\d{4})">
-          <leadingDigits>911</leadingDigits>
-          <format>$1 $2 $3 $4</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(9)(\d{4})(\d{2})(\d{4})">
-          <leadingDigits>9(?:1[02-9]|[23])</leadingDigits>
-          <format>$1 $2 $3 $4</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(\d{3})(\d{3})(\d{4})">
-          <leadingDigits>[68]</leadingDigits>
-          <format>$1-$2-$3</format>
-        </intlNumberFormat>
       </availableFormats>
       <generalDesc>
         <nationalNumberPattern>[1-3689]\d{9,10}</nationalNumberPattern>
@@ -489,7 +471,7 @@
     <!-- Mexico -->
     <territory id="MX" countryCode="52" internationalPrefix="00"
                nationalPrefix="01" nationalPrefixForParsing="01|04[45](\d{10})"
-               nationalPrefixTransformRule="1$1">
+               nationalPrefixTransformRule="1$1" nationalPrefixFormattingRule="$NP $FG">
       <availableFormats>
         <numberFormat pattern="(\d{3})(\d{3})(\d{4})">
           <leadingDigits>[89]00</leadingDigits>
@@ -503,34 +485,16 @@
           <leadingDigits>[2467]|3[0-24-9]|5[0-46-9]|8[2-9]|9[1-9]</leadingDigits>
           <format>$1 $2 $3</format>
         </numberFormat>
-        <numberFormat pattern="1(\d{2})(\d{4})(\d{4})">
+        <numberFormat nationalPrefixFormattingRule="$FG" pattern="(1)(\d{2})(\d{4})(\d{4})">
           <leadingDigits>1(?:33|55|81)</leadingDigits>
-          <format>045 $1 $2 $3</format>
+          <format>045 $2 $3 $4</format>
+          <intlFormat>$1 $2 $3 $4</intlFormat>
         </numberFormat>
-        <numberFormat pattern="1(\d{3})(\d{3})(\d{4})">
+        <numberFormat nationalPrefixFormattingRule="$FG" pattern="(1)(\d{3})(\d{3})(\d{4})">
           <leadingDigits>1(?:[124579]|3[0-24-9]|5[0-46-9]|8[02-9])</leadingDigits>
-          <format>045 $1 $2 $3</format>
+          <format>045 $2 $3 $4</format>
+          <intlFormat>$1 $2 $3 $4</intlFormat>
         </numberFormat>
-        <intlNumberFormat pattern="(\d{3})(\d{3})(\d{4})">
-          <leadingDigits>[89]00</leadingDigits>
-          <format>$1 $2 $3</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(\d{2})(\d{4})(\d{4})">
-          <leadingDigits>33|55|81</leadingDigits>
-          <format>$1 $2 $3</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(\d{3})(\d{3})(\d{4})">
-          <leadingDigits>[2467]|3[0-24-9]|5[0-46-9]|8[2-9]|9[1-9]</leadingDigits>
-          <format>$1 $2 $3</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(1)(\d{2})(\d{4})(\d{4})">
-          <leadingDigits>1(?:33|55|81)</leadingDigits>
-          <format>$1 $2 $3 $4</format>
-        </intlNumberFormat>
-        <intlNumberFormat pattern="(1)(\d{3})(\d{3})(\d{4})">
-          <leadingDigits>1(?:[124579]|3[0-24-9]|5[0-46-9]|8[02-9])</leadingDigits>
-          <format>$1 $2 $3 $4</format>
-        </intlNumberFormat>
       </availableFormats>
       <generalDesc>
         <nationalNumberPattern>[1-9]\d{9,10}</nationalNumberPattern>
@@ -713,10 +677,8 @@
         </numberFormat>
         <numberFormat pattern="(\d{3})(\d{4})">
           <format>$1 $2</format>
-        </numberFormat>
-        <intlNumberFormat pattern="(\d{3})(\d{3})(\d{4})">
-          <format>$1 $2 $3</format>
-        </intlNumberFormat>
+          <intlFormat>NA</intlFormat>
+       </numberFormat>
       </availableFormats>
       <generalDesc>
         <nationalNumberPattern>[13-9]\d{9}|2[0-35-9]\d{8}</nationalNumberPattern>