8363972: Lenient parsing of minus sign pattern in DecimalFormat/CompactNumberFormat

naotoj · naotoj · commit 23670fd41895 · 2025-08-26T21:49:57.000Z
Reviewed-by: jlu, rriggs
diff --git a/make/jdk/src/classes/build/tools/cldrconverter/Bundle.java b/make/jdk/src/classes/build/tools/cldrconverter/Bundle.java
@@ -79,6 +79,7 @@ static enum Type {
         "NumberElements/nan",
         "NumberElements/currencyDecimal",
         "NumberElements/currencyGroup",
+        "NumberElements/lenientMinusSigns",
     };
 
     private static final String[] TIME_PATTERN_KEYS = {
diff --git a/make/jdk/src/classes/build/tools/cldrconverter/LDMLParseHandler.java b/make/jdk/src/classes/build/tools/cldrconverter/LDMLParseHandler.java
@@ -844,6 +844,26 @@ public void startElement(String uri, String localName, String qName, Attributes
                 });
             break;
 
+        // Lenient parsing
+        case "parseLenients":
+            if ("lenient".equals(attributes.getValue("level"))) {
+                pushKeyContainer(qName, attributes, attributes.getValue("scope"));
+            } else {
+                pushIgnoredContainer(qName);
+            }
+            break;
+
+        case "parseLenient":
+            // Use only the lenient minus sign for now
+            if (currentContainer instanceof KeyContainer kc
+                && kc.getKey().equals("number")
+                && attributes.getValue("sample").equals("-")) {
+                pushStringEntry(qName, attributes, currentNumberingSystem + "NumberElements/lenientMinusSigns");
+            } else {
+                pushIgnoredContainer(qName);
+            }
+            break;
+
         default:
             // treat anything else as a container
             pushContainer(qName, attributes);
@@ -1150,6 +1170,14 @@ public void endElement(String uri, String localName, String qName) throws SAXExc
             currentStyle = "";
             putIfEntry();
             break;
+        case "parseLenient":
+            if (currentContainer instanceof StringEntry se) {
+                // Convert to a simple concatenation of lenient minuses
+                // e.g. "[\-－﹣ ‐‑ ‒ – −⁻₋ ➖]" -> "-－﹣‐‑‒–−⁻₋➖" for the root locale
+                put(se.getKey(), se.getValue().replaceAll("[\\[\\]\\\\ ]", ""));
+            }
+            break;
+
         default:
             putIfEntry();
         }
diff --git a/src/java.base/share/classes/java/text/CompactNumberFormat.java b/src/java.base/share/classes/java/text/CompactNumberFormat.java
@@ -147,7 +147,7 @@
  * a compact pattern. This special pattern can appear explicitly for any specific
  * range, or considered as a default pattern for an empty string.
  *
- * <h3>Negative Subpatterns</h3>
+ * <h3><a id="negative_subpatterns">Negative Subpatterns</a></h3>
  * A compact pattern contains a positive and negative subpattern
  * separated by a subpattern boundary character {@code ';'},
  * for example, {@code "0K;-0K"}. Each subpattern has a prefix,
@@ -159,7 +159,10 @@
  * the negative prefix and suffix. The number of minimum integer digits,
  * and other characteristics are all the same as the positive pattern.
  * That means that {@code "0K;-00K"} produces precisely the same behavior
- * as {@code "0K;-0K"}.
+ * as {@code "0K;-0K"}. In {@link NumberFormat##leniency lenient parsing}
+ * mode, loose matching of the minus sign pattern is enabled, following the
+ * LDML’s <a href="https://unicode.org/reports/tr35/#Loose_Matching">
+ * loose matching</a> specification.
  *
  * <h4>Escaping Special Characters</h4>
  * Many characters in a compact pattern are taken literally, they are matched
@@ -1585,6 +1588,9 @@ private void expandAffixPatterns() {
      *   and are not digits that occur within the numerical portion
      * </ul>
      * <p>
+     * When lenient, the minus sign in the {@link ##negative_subpatterns
+     * negative subpatterns} is loosely matched against lenient minus sign characters.
+     * <p>
      * The subclass returned depends on the value of
      * {@link #isParseBigDecimal}.
      * <ul>
@@ -1693,14 +1699,12 @@ public Number parse(String text, ParsePosition pos) {
         // Given text does not match the non empty valid compact prefixes
         // check with the default prefixes
         if (!gotPositive && !gotNegative) {
-            if (text.regionMatches(pos.index, defaultPosPrefix, 0,
-                    defaultPosPrefix.length())) {
+            if (decimalFormat.matchAffix(text, position, defaultPosPrefix)) {
                 // Matches the default positive prefix
                 matchedPosPrefix = defaultPosPrefix;
                 gotPositive = true;
             }
-            if (text.regionMatches(pos.index, defaultNegPrefix, 0,
-                    defaultNegPrefix.length())) {
+            if (decimalFormat.matchAffix(text, position, defaultNegPrefix)) {
                 // Matches the default negative prefix
                 matchedNegPrefix = defaultNegPrefix;
                 gotNegative = true;
@@ -1924,7 +1928,7 @@ private boolean matchAffix(String text, int position, String affix,
         if (!affix.isEmpty() && !affix.equals(defaultAffix)) {
             // Look ahead only for the longer match than the previous match
             if (matchedAffix.length() < affix.length()) {
-                return text.regionMatches(position, affix, 0, affix.length());
+                return decimalFormat.matchAffix(text, position, affix);
             }
         }
         return false;
@@ -2026,17 +2030,15 @@ private Number computeParseMultiplier(String text, ParsePosition parsePosition,
         if (!gotPos && !gotNeg) {
             String positiveSuffix = defaultDecimalFormat.getPositiveSuffix();
             String negativeSuffix = defaultDecimalFormat.getNegativeSuffix();
-            boolean containsPosSuffix = text.regionMatches(position,
-                    positiveSuffix, 0, positiveSuffix.length());
+            boolean containsPosSuffix = decimalFormat.matchAffix(text, position, positiveSuffix);
             boolean endsWithPosSuffix = containsPosSuffix && text.length() ==
                     position + positiveSuffix.length();
             if (parseStrict ? endsWithPosSuffix : containsPosSuffix) {
                 // Matches the default positive prefix
                 matchedPosSuffix = positiveSuffix;
                 gotPos = true;
             }
-            boolean containsNegSuffix = text.regionMatches(position,
-                    negativeSuffix, 0, negativeSuffix.length());
+            boolean containsNegSuffix = decimalFormat.matchAffix(text, position, negativeSuffix);
             boolean endsWithNegSuffix = containsNegSuffix && text.length() ==
                     position + negativeSuffix.length();
             if (parseStrict ? endsWithNegSuffix : containsNegSuffix) {
diff --git a/src/java.base/share/classes/java/text/DecimalFormat.java b/src/java.base/share/classes/java/text/DecimalFormat.java
@@ -296,7 +296,7 @@
  * #setMaximumIntegerDigits(int)} can be used to manually adjust the maximum
  * integer digits.
  *
- * <h3>Negative Subpatterns</h3>
+ * <h3><a id="negative_subpatterns">Negative Subpatterns</a></h3>
  * A {@code DecimalFormat} pattern contains a positive and negative
  * subpattern, for example, {@code "#,##0.00;(#,##0.00)"}.  Each
  * subpattern has a prefix, numeric part, and suffix. The negative subpattern
@@ -307,7 +307,11 @@
  * serves only to specify the negative prefix and suffix; the number of digits,
  * minimal digits, and other characteristics are all the same as the positive
  * pattern. That means that {@code "#,##0.0#;(#)"} produces precisely
- * the same behavior as {@code "#,##0.0#;(#,##0.0#)"}.
+ * the same behavior as {@code "#,##0.0#;(#,##0.0#)"}. In
+ * {@link NumberFormat##leniency lenient parsing} mode, loose matching of the
+ * minus sign pattern is enabled, following the LDML’s
+ * <a href="https://unicode.org/reports/tr35/#Loose_Matching">
+ * loose matching</a> specification.
  *
  * <p>The prefixes, suffixes, and various symbols used for infinity, digits,
  * grouping separators, decimal separators, etc. may be set to arbitrary
@@ -2189,6 +2193,9 @@ private void append(StringBuf result, String string,
      *   and are not digits that occur within the numerical portion
      * </ul>
      * <p>
+     * When lenient, the minus sign in the {@link ##negative_subpatterns
+     * negative subpatterns} is loosely matched against lenient minus sign characters.
+     * <p>
      * The subclass returned depends on the value of {@link #isParseBigDecimal}
      * as well as on the string being parsed.
      * <ul>
@@ -2385,10 +2392,8 @@ private final boolean subparse(String text, ParsePosition parsePosition,
         boolean gotPositive, gotNegative;
 
         // check for positivePrefix; take longest
-        gotPositive = text.regionMatches(position, positivePrefix, 0,
-                positivePrefix.length());
-        gotNegative = text.regionMatches(position, negativePrefix, 0,
-                negativePrefix.length());
+        gotPositive = matchAffix(text, position, positivePrefix);
+        gotNegative = matchAffix(text, position, negativePrefix);
 
         if (gotPositive && gotNegative) {
             if (positivePrefix.length() > negativePrefix.length()) {
@@ -2424,15 +2429,13 @@ private final boolean subparse(String text, ParsePosition parsePosition,
         // When lenient, text only needs to contain the suffix.
         if (!isExponent) {
             if (gotPositive) {
-                boolean containsPosSuffix =
-                        text.regionMatches(position, positiveSuffix, 0, positiveSuffix.length());
+                boolean containsPosSuffix = matchAffix(text, position, positiveSuffix);
                 boolean endsWithPosSuffix =
                         containsPosSuffix && text.length() == position + positiveSuffix.length();
                 gotPositive = parseStrict ? endsWithPosSuffix : containsPosSuffix;
             }
             if (gotNegative) {
-                boolean containsNegSuffix =
-                        text.regionMatches(position, negativeSuffix, 0, negativeSuffix.length());
+                boolean containsNegSuffix = matchAffix(text, position, negativeSuffix);
                 boolean endsWithNegSuffix =
                         containsNegSuffix && text.length() == position + negativeSuffix.length();
                 gotNegative = parseStrict ? endsWithNegSuffix : containsNegSuffix;
@@ -3501,6 +3504,54 @@ private void appendAffix(StringBuilder buffer, String affix, boolean localized)
         if (needQuote) buffer.append('\'');
     }
 
+    /**
+     * {@return true if the text matches the affix}
+     * In lenient mode, lenient minus signs also match the hyphen-minus
+     * (U+002D). Package-private access, as this is called from
+     * CompactNumberFormat.
+     *
+     * Note: Minus signs in the supplementary character range or normalization
+     * equivalents are not matched, as they may alter the affix length.
+     */
+    boolean matchAffix(String text, int position, String affix) {
+        var alen = affix.length();
+        var tlen = text.length();
+
+        if (alen == 0) {
+            // always match with an empty affix, as affix is optional
+            return true;
+        }
+        if (position >= tlen) {
+            return false;
+        }
+        if (parseStrict) {
+            return text.regionMatches(position, affix, 0, alen);
+        }
+
+        var lms = symbols.getLenientMinusSigns();
+        int i = 0;
+        int limit = Math.min(tlen, position + alen);
+        for (; position + i < limit; i++) {
+            char t = text.charAt(position + i);
+            char a = affix.charAt(i);
+            int tIndex = lms.indexOf(t);
+            int aIndex = lms.indexOf(a);
+            // Non LMS. Match direct
+            if (tIndex < 0 && aIndex < 0) {
+                if (t != a) {
+                    return false;
+                }
+            } else {
+                // By here, at least one LMS. Ensure both LMS.
+                if (tIndex < 0 || aIndex < 0) {
+                    return false;
+                }
+            }
+        }
+        // Return true if entire affix was matched
+        return i == alen;
+    }
+
     /**
      * Implementation of producing a pattern. This method returns a positive and
      * negative (if needed), pattern string in the form of : Prefix (optional)
diff --git a/src/java.base/share/classes/java/text/DecimalFormatSymbols.java b/src/java.base/share/classes/java/text/DecimalFormatSymbols.java
@@ -718,6 +718,17 @@ void setMinusSignText(String minusSignText) {
         this.minusSign = findNonFormatChar(minusSignText, '-');
     }
 
+    /**
+     * {@return the lenient minus signs} Multiple lenient minus signs
+     * are concatenated to form the returned string. Each codepoint
+     * in the string is a valid minus sign pattern. If there are no
+     * lenient minus signs defined in this locale, {@code minusSignText}
+     * is returned.
+     */
+    String getLenientMinusSigns() {
+        return lenientMinusSigns;
+    }
+
     //------------------------------------------------------------
     // END     Package Private methods ... to be made public later
     //------------------------------------------------------------
@@ -818,18 +829,7 @@ public int hashCode() {
     private void initialize(Locale locale) {
         this.locale = locale;
 
-        // check for region override
-        Locale override = locale.getUnicodeLocaleType("nu") == null ?
-            CalendarDataUtility.findRegionOverride(locale) :
-            locale;
-
-        // get resource bundle data
-        LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(DecimalFormatSymbolsProvider.class, override);
-        // Avoid potential recursions
-        if (!(adapter instanceof ResourceBundleBasedAdapter)) {
-            adapter = LocaleProviderAdapter.getResourceBundleBased();
-        }
-        Object[] data = adapter.getLocaleResources(override).getDecimalFormatSymbolsData();
+        Object[] data = loadNumberData(locale);
         String[] numberElements = (String[]) data[0];
 
         decimalSeparator = numberElements[0].charAt(0);
@@ -854,11 +854,30 @@ private void initialize(Locale locale) {
         monetaryGroupingSeparator = numberElements.length < 13 || numberElements[12].isEmpty() ?
             groupingSeparator : numberElements[12].charAt(0);
 
+        // Lenient minus signs
+        lenientMinusSigns = numberElements.length < 14 ? minusSignText : numberElements[13];
+
         // maybe filled with previously cached values, or null.
         intlCurrencySymbol = (String) data[1];
         currencySymbol = (String) data[2];
     }
 
+    private Object[] loadNumberData(Locale locale) {
+        // check for region override
+        Locale override = locale.getUnicodeLocaleType("nu") == null ?
+            CalendarDataUtility.findRegionOverride(locale) :
+            locale;
+
+        // get resource bundle data
+        LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(DecimalFormatSymbolsProvider.class, override);
+        // Avoid potential recursions
+        if (!(adapter instanceof ResourceBundleBasedAdapter)) {
+            adapter = LocaleProviderAdapter.getResourceBundleBased();
+        }
+
+        return adapter.getLocaleResources(override).getDecimalFormatSymbolsData();
+    }
+
     /**
      * Obtains non-format single character from String
      */
@@ -995,6 +1014,14 @@ private void readObject(ObjectInputStream stream)
             }
             currencyInitialized = true;
         }
+
+        if (loadNumberData(locale) instanceof Object[] d &&
+            d[0] instanceof String[] numberElements &&
+            numberElements.length >= 14) {
+            lenientMinusSigns = numberElements[13];
+        } else {
+            lenientMinusSigns = minusSignText;
+        }
     }
 
     /**
@@ -1174,6 +1201,9 @@ private void readObject(ObjectInputStream stream)
     private transient Currency currency;
     private transient volatile boolean currencyInitialized;
 
+    // Lenient minus. No need to be set by applications
+    private transient String lenientMinusSigns;
+
     /**
      * Cached hash code.
      */
diff --git a/src/java.base/share/classes/java/text/NumberFormat.java b/src/java.base/share/classes/java/text/NumberFormat.java
@@ -195,7 +195,11 @@
  * Lenient parsing should be used when attempting to parse a number
  * out of a String that contains non-numerical or non-format related values.
  * For example, using a {@link Locale#US} currency format to parse the number
- * {@code 1000} out of the String "$1,000.00 was paid".
+ * {@code 1000} out of the String "$1,000.00 was paid". Lenient parsing also
+ * allows loose matching of characters in the source text. For example, an
+ * implementation of the {@code NumberFormat} class may allow matching "−"
+ * (U+2212 MINUS SIGN) to the "-" (U+002D HYPHEN-MINUS) pattern character
+ * when used as a negative prefix.
  * <p>
  * Strict parsing should be used when attempting to ensure a String adheres exactly
  * to a locale's conventions, and can thus serve to validate input. For example, successfully
diff --git a/test/jdk/java/text/Format/CompactNumberFormat/TestCompactNumber.java b/test/jdk/java/text/Format/CompactNumberFormat/TestCompactNumber.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -22,7 +22,7 @@
  */
 /*
  * @test
- * @bug 8177552 8217721 8222756 8295372 8306116 8319990 8338690
+ * @bug 8177552 8217721 8222756 8295372 8306116 8319990 8338690 8363972
  * @summary Checks the functioning of compact number format
  * @modules jdk.localedata
  * @run testng/othervm TestCompactNumber
@@ -462,6 +462,8 @@ Object[][] compactParseData() {
                 {FORMAT_SE_SHORT, "12345679,89\u00a0bn", 1.2345679890000001E19, Double.class},
                 {FORMAT_SE_SHORT, "\u2212999", -999L, Long.class},
                 {FORMAT_SE_SHORT, "\u22128\u00a0mn", -8000000L, Long.class},
+                // lenient parsing. Hyphen-minus should match the localized minus sign
+                {FORMAT_SE_SHORT, "-8\u00a0mn", -8000000L, Long.class},
                 {FORMAT_SE_SHORT, "\u22128\u00a0dt", -8000L, Long.class},
                 {FORMAT_SE_SHORT, "\u221212345679\u00a0bn", -1.2345679E19, Double.class},
                 {FORMAT_SE_SHORT, "\u221212345679,89\u00a0bn", -1.2345679890000001E19, Double.class},
@@ -503,8 +505,7 @@ Object[][] exceptionParseData() {
             {FORMAT_EN_US_SHORT, "K12,347", null},
             // Invalid prefix for ja_JP
             {FORMAT_JA_JP_SHORT, "\u4E071", null},
-            // Localized minus sign should be used
-            {FORMAT_SE_SHORT, "-8\u00a0mn", null},};
+        };
     }
 
     @DataProvider(name = "invalidParse")
diff --git a/test/jdk/java/text/Format/NumberFormat/LenientMinusSignTest.java b/test/jdk/java/text/Format/NumberFormat/LenientMinusSignTest.java
