src/java.base/share/classes/java/lang/StringLatin1.java

rev 55811 : 8229283: StringLatin1 should consistently use CharacterDataLatin1.instance when applicable
Reviewed-by: TBD

@@ -175,11 +175,11 @@
         int lim = Math.min(len1, len2);
         for (int k = 0; k < lim; k++) {
             char c1 = getChar(value, k);
             char c2 = StringUTF16.getChar(other, k);
             if (c1 != c2) {
-                c1 = Character.toUpperCase(c1);
+                c1 = (char) CharacterDataLatin1.instance.toUpperCase(c1);
                 c2 = Character.toUpperCase(c2);
                 if (c1 != c2) {
                     c1 = Character.toLowerCase(c1);
                     c2 = Character.toLowerCase(c2);
                     if (c1 != c2) {

@@ -389,12 +389,12 @@
             char c1 = (char)(value[toffset++] & 0xff);
             char c2 = (char)(other[ooffset++] & 0xff);
             if (c1 == c2) {
                 continue;
             }
-            char u1 = Character.toUpperCase(c1);
-            char u2 = Character.toUpperCase(c2);
+            int u1 = CharacterDataLatin1.instance.toUpperCase(c1);
+            int u2 = CharacterDataLatin1.instance.toUpperCase(c2);
             if (u1 == u2) {
                 continue;
             }
             if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                 continue;

@@ -411,11 +411,11 @@
             char c1 = (char)(value[toffset++] & 0xff);
             char c2 = StringUTF16.getChar(other, ooffset++);
             if (c1 == c2) {
                 continue;
             }
-            char u1 = Character.toUpperCase(c1);
+            char u1 = (char) CharacterDataLatin1.instance.toUpperCase(c1);
             char u2 = Character.toUpperCase(c2);
             if (u1 == u2) {
                 continue;
             }
             if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {

@@ -433,11 +433,11 @@
         int first;
         final int len = value.length;
         // Now check if there are any characters that need to be changed, or are surrogate
         for (first = 0 ; first < len; first++) {
             int cp = value[first] & 0xff;
-            if (cp != Character.toLowerCase(cp)) {  // no need to check Character.ERROR
+            if (cp != CharacterDataLatin1.instance.toLowerCase(cp)) {  // no need to check Character.ERROR
                 break;
             }
         }
         if (first == len)
             return str;

@@ -448,11 +448,11 @@
         byte[] result = new byte[len];
         System.arraycopy(value, 0, result, 0, first);  // Just copy the first few
                                                        // lowerCase characters.
         for (int i = first; i < len; i++) {
             int cp = value[i] & 0xff;
-            cp = Character.toLowerCase(cp);
+            cp = CharacterDataLatin1.instance.toLowerCase(cp);
             if (!canEncode(cp)) {                      // not a latin1 character
                 return toLowerCaseEx(str, value, first, locale, false);
             }
             result[i] = (byte)cp;
         }

@@ -472,11 +472,11 @@
             int lowerChar;
             char[] lowerCharArray;
             if (localeDependent) {
                 lowerChar = ConditionalSpecialCasing.toLowerCaseEx(str, i, locale);
             } else {
-                lowerChar = Character.toLowerCase(srcChar);
+                lowerChar = CharacterDataLatin1.instance.toLowerCase(srcChar);
             }
             if (Character.isBmpCodePoint(lowerChar)) {    // Character.ERROR is not a bmp
                 StringUTF16.putChar(result, resultOffset++, lowerChar);
             } else {
                 if (lowerChar == Character.ERROR) {

@@ -507,11 +507,11 @@
         final int len = value.length;
 
         // Now check if there are any characters that need to be changed, or are surrogate
         for (first = 0 ; first < len; first++ ) {
             int cp = value[first] & 0xff;
-            if (cp != Character.toUpperCaseEx(cp)) {   // no need to check Character.ERROR
+            if (cp != CharacterDataLatin1.instance.toUpperCaseEx(cp)) {   // no need to check Character.ERROR
                 break;
             }
         }
         if (first == len) {
             return str;

@@ -523,11 +523,11 @@
         byte[] result = new byte[len];
         System.arraycopy(value, 0, result, 0, first);  // Just copy the first few
                                                        // upperCase characters.
         for (int i = first; i < len; i++) {
             int cp = value[i] & 0xff;
-            cp = Character.toUpperCaseEx(cp);
+            cp = CharacterDataLatin1.instance.toUpperCaseEx(cp);
             if (!canEncode(cp)) {                      // not a latin1 character
                 return toUpperCaseEx(str, value, first, locale, false);
             }
             result[i] = (byte)cp;
         }

@@ -547,21 +547,21 @@
             int upperChar;
             char[] upperCharArray;
             if (localeDependent) {
                 upperChar = ConditionalSpecialCasing.toUpperCaseEx(str, i, locale);
             } else {
-                upperChar = Character.toUpperCaseEx(srcChar);
+                upperChar = CharacterDataLatin1.instance.toUpperCaseEx(srcChar);
             }
             if (Character.isBmpCodePoint(upperChar)) {
                 StringUTF16.putChar(result, resultOffset++, upperChar);
             } else {
                 if (upperChar == Character.ERROR) {
                     if (localeDependent) {
                         upperCharArray =
                             ConditionalSpecialCasing.toUpperCaseCharArray(str, i, locale);
                     } else {
-                        upperCharArray = Character.toUpperCaseCharArray(srcChar);
+                        upperCharArray = CharacterDataLatin1.instance.toUpperCaseCharArray(srcChar);
                     }
                 } else {
                     upperCharArray = Character.toChars(upperChar);
                 }
                 /* Grow result if needed */

@@ -595,11 +595,11 @@
     public static int indexOfNonWhitespace(byte[] value) {
         int length = value.length;
         int left = 0;
         while (left < length) {
             char ch = getChar(value, left);
-            if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
+            if (ch != ' ' && ch != '\t' && !CharacterDataLatin1.instance.isWhitespace(ch)) {
                 break;
             }
             left++;
         }
         return left;

@@ -608,11 +608,11 @@
     public static int lastIndexOfNonWhitespace(byte[] value) {
         int length = value.length;
         int right = length;
         while (0 < right) {
             char ch = getChar(value, right - 1);
-            if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
+            if (ch != ' ' && ch != '\t' && !CharacterDataLatin1.instance.isWhitespace(ch)) {
                 break;
             }
             right--;
         }
         return right;