6803681: RFE: Need new codeset converter for IBM Cp1364

Summary: forward port the Cp1364
Reviewed-by: alanb

make/sun/nio/cs/FILES_java.gmk

@@ -376,6 +376,7 @@ FILES_gen_extcs = \
         sun/nio/cs/ext/HKSCSMapping.java \
         sun/nio/cs/ext/HKSCS2001Mapping.java \
         sun/nio/cs/ext/HKSCS_XPMapping.java \
+	sun/nio/cs/ext/IBM1364.java \
 	sun/nio/cs/ext/IBM1381.java \
 	sun/nio/cs/ext/IBM1383.java \
 	sun/nio/cs/ext/IBM930.java \

make/tools/CharsetMapping/IBM1364.c2b

+# 
+# Diff of 
+# b2c: cdctables.zip/Package2.zip/IBM-1364A.zip/055444B0.TPMAP110
+# c2b: cdctables.zip/Package2.zip/IBM-1364A.zip/055444B0.UPMAP110
+# shows there are 6 additional c->b entries in UPMAP110, they are
+# listed below (in b->c form)
+#
+# UPMAP110 also defines
+#      <subchar>    \xFE\xFE
+# and commend out
+#      #<subchar1>  \x3F
+# with
+#
+# <UFFFD>         \xFE\xFD            #  (SUB)
+# <UFFFD>         \xFE\xFE            #  (SUB)
+#
+4148    00AD
+4143    00B7
+4149    2015
+42A1    223C
+496F    2299
+4954    FF5E

make/tools/CharsetMapping/dbcs

@@ -10,6 +10,7 @@ MS936	  x-mswin-936 MS936   basic     sun.nio.cs.ext    true    0x81   0xfe   0x
 MS949	  x-windows-949 MS949 basic     sun.nio.cs.ext    true    0x81   0xfe   0x41  0xfe
 MS950	  x-windows-950 MS950 basic     sun.nio.cs.ext    true    0x81   0xfe   0x40  0xfe
 GBK	  GBK        GBK      basic     sun.nio.cs.ext    true    0x81   0xfe   0x40  0xfe
+IBM1364	  x-IBM1364  Cp1364   ebcdic	sun.nio.cs.ext	  false   0x40   0xde   0x40  0xfe
 IBM1381	  x-IBM1381  Cp1381   basic     sun.nio.cs.ext    true    0x8c   0xf7   0xa1  0xfe
 IBM1383	  x-IBM1383  Cp1383   euc_sim   sun.nio.cs.ext    true    0xa1   0xfe   0xa1  0xfe
 IBM930	  x-IBM930   Cp930    ebcdic    sun.nio.cs.ext    false   0x40   0x7f   0x40  0xfe

src/share/classes/sun/nio/cs/ext/ExtendedCharsets.java

@@ -679,6 +679,14 @@ public class ExtendedCharsets
                     "1124"
                 });
 
+        charset("x-IBM1364", "IBM1364",
+                new String[] {
+                    "cp1364",
+                    "ibm1364",
+                    "ibm-1364",
+                    "1364"
+                });
+
         charset("IBM273", "IBM273",
                 new String[] {
                     "cp273", // JDK historical

test/sun/nio/cs/TestIBM1364.java

+/*
+ * Copyright (c) 2011, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+/* @test
+   @bug 6803681
+   @summary Test IBM1364
+ */
+
+import java.util.Arrays;
+import java.nio.*;
+import java.nio.charset.*;
+
+public class TestIBM1364 {
+    private static String c2bNRStr = "\u00AD\u00B7\u2015\u223C\u2299\uFF5E";
+    private static byte[] c2bNRBytes = new byte[] {
+        (byte)0x0e,
+        (byte)0x41, (byte)0x48,
+        (byte)0x41, (byte)0x43,
+        (byte)0x41, (byte)0x49,
+        (byte)0x42, (byte)0xa1,
+        (byte)0x49, (byte)0x6f,
+        (byte)0x49, (byte)0x54,
+        (byte)0x0f };
+
+    // end at SO
+    private static String mixedStr = "\u008d\u008e\u0020\u3000\u3001\u71ba\u3164\u0088\ue757";
+    private static byte[] mixedBytes = new byte[] {
+         (byte)0x09,
+         (byte)0x0a,
+         (byte)0x40,
+         (byte)0x0e,
+         (byte)0x40, (byte)0x40,
+         (byte)0x41, (byte)0x41,
+         (byte)0x6c, (byte)0x45,
+         (byte)0x84, (byte)0x41,
+         (byte)0x0f,
+         (byte)0x28,
+         (byte)0x0e,
+         (byte)0xdd, (byte)0xfd,
+         (byte)0x0f };
+
+    // end at SI
+    private static String mixedStr2 = "\u008d\u008e\u0020\u3000\u3001\u71ba\u3164\u0088";
+    private static byte[] mixedBytes2 = new byte[] {
+         (byte)0x09,
+         (byte)0x0a,
+         (byte)0x40,
+         (byte)0x0e,
+         (byte)0x40, (byte)0x40,
+         (byte)0x41, (byte)0x41,
+         (byte)0x6c, (byte)0x45,
+         (byte)0x84, (byte)0x41,
+         (byte)0x0f,
+         (byte)0x28 };
+
+    private static byte[][] malformedBytes = {
+        { (byte)0x0e,
+          (byte)0x039, (byte)0x40,
+          (byte)0x0f
+        },
+        { (byte)0x0e,
+          (byte)0x039, (byte)0x42,
+          (byte)0x0f
+        },
+        { (byte)0x0e,
+          (byte)0x040, (byte)0x41,
+          (byte)0x0f
+        },
+        { (byte)0x0e,
+          (byte)0x040, (byte)0xee,
+          (byte)0x0f
+        },
+        { (byte)0x0e,
+          (byte)0x0ef, (byte)0x30,
+          (byte)0x0f
+        },
+        { (byte)0x0e,
+          (byte)0x0ff, (byte)0x41,
+          (byte)0x0f
+        }
+    };
+
+    private static byte[][] unmappedBytes = {
+        { (byte)0x0e,
+          (byte)0x06c, (byte)0x46,
+          (byte)0x0f,
+        },
+        { (byte)0x0e,
+          (byte)0x078, (byte)0x46,
+          (byte)0x0f,
+        },
+        { (byte)0x0e,
+          (byte)0x083, (byte)0xfe,
+          (byte)0x0f,
+        },
+        { (byte)0xfa },
+        { (byte)0xfe },
+    };
+
+    public static void main(String[] args) throws Exception {
+        if (!(Arrays.equals(mixedStr.getBytes("cp1364"), mixedBytes)) ||
+            !mixedStr.equals(new String(mixedBytes, "cp1364")))
+            throw new RuntimeException("cp1364 failed on mixed!");
+
+        if (!(Arrays.equals(mixedStr2.getBytes("cp1364"), mixedBytes2)) ||
+            !mixedStr2.equals(new String(mixedBytes2, "cp1364")))
+            throw new RuntimeException("cp1364 failed on mixed!");
+
+        if (!(Arrays.equals(c2bNRStr.getBytes("cp1364"), c2bNRBytes)) ||
+            c2bNRStr.equals(new String(c2bNRBytes, "cp1364")))
+            throw new RuntimeException("cp1364 failed on c2bNR!");
+
+        ByteBuffer bb = ByteBuffer.allocateDirect(mixedBytes.length);
+        bb.put(mixedBytes).flip();
+        CharBuffer cb = Charset.forName("ibm1364").decode(bb);
+        if (!mixedStr.equals(new String(cb.toString())))
+            throw new RuntimeException("cp1364 failed on direct decod()!");
+
+        bb = ByteBuffer.allocateDirect(mixedBytes2.length);
+        bb.put(mixedBytes2).flip();
+        cb = Charset.forName("ibm1364").decode(bb);
+        if (!mixedStr2.equals(new String(cb.toString())))
+            throw new RuntimeException("cp1364 failed on direct decod()!");
+
+        cb = ByteBuffer.allocateDirect(mixedStr.length() * 2).asCharBuffer();
+        cb.put(mixedStr.toCharArray()).flip();
+        bb = Charset.forName("x-ibm1364").encode(cb);
+        if (!(Arrays.equals(Arrays.copyOf(bb.array(), bb.limit()), mixedBytes)))
+            throw new RuntimeException("cp1364 failed on direct encode()!");
+
+        cb = ByteBuffer.allocateDirect(mixedStr2.length() * 2).asCharBuffer();
+        cb.put(mixedStr2.toCharArray()).flip();
+        bb = Charset.forName("x-ibm1364").encode(cb);
+        if (!(Arrays.equals(Arrays.copyOf(bb.array(), bb.limit()), mixedBytes2)))
+            throw new RuntimeException("cp1364 failed on direct encode()!");
+
+        // malformed
+        cb = CharBuffer.allocate(1024);
+        CharBuffer cbd = ByteBuffer.allocateDirect(1024).asCharBuffer();
+        CharsetDecoder dec = Charset.forName("x-ibm1364").newDecoder();
+        for (byte[] ba:malformedBytes) {
+            cb.clear();
+            dec.reset();
+            if (!dec.reset().decode(ByteBuffer.wrap(ba), cb, true).isMalformed() ||
+                !dec.reset().decode(ByteBuffer.wrap(ba), cbd, true).isMalformed())
+                throw new RuntimeException("cp1364 failed on decode()/malformed!");
+        }
+
+        //unmappable
+        for (byte[] ba:unmappedBytes) {
+            cb.clear();
+            dec.reset();
+            if (!dec.reset().decode(ByteBuffer.wrap(ba), cb, true).isUnmappable() ||
+                !dec.reset().decode(ByteBuffer.wrap(ba), cbd, true).isUnmappable())
+                throw new RuntimeException("cp1364 failed on decode()/unmappable!");
+        }
+
+        //overflow
+        cb.limit(mixedStr.length() - 1);
+        cbd.limit(mixedStr.length() - 1);
+        if (!dec.reset().decode(ByteBuffer.wrap(mixedBytes), cb, true).isOverflow() ||
+            !dec.reset().decode(ByteBuffer.wrap(mixedBytes), cbd, true).isOverflow())
+            throw new RuntimeException("cp1364 failed on decode()/overflow!");
+
+        CharsetEncoder enc = Charset.forName("x-ibm1364").newEncoder();
+        // last "0x0f" is from flush()
+        bb = ByteBuffer.allocate(mixedBytes.length - 2);
+        ByteBuffer bbd = ByteBuffer.allocateDirect(mixedBytes.length - 2);
+        if (!enc.reset()
+                .encode(CharBuffer.wrap(mixedStr.toCharArray()), bb, true)
+                .isOverflow() ||
+            !enc.reset()
+                .encode(CharBuffer.wrap(mixedStr.toCharArray()), bbd, true)
+                .isOverflow())
+            throw new RuntimeException("cp1364 failed on encode()/overflow!");
+
+        // flush() overflow
+        bb = ByteBuffer.allocate(mixedBytes.length - 1);
+        bbd = ByteBuffer.allocateDirect(mixedBytes.length - 1);
+
+        enc.reset().encode(CharBuffer.wrap(mixedStr.toCharArray()), bb, true);
+        enc.reset().encode(CharBuffer.wrap(mixedStr.toCharArray()), bbd, true);
+
+        if (!enc.flush(bb).isOverflow() ||
+            !enc.flush(bbd).isOverflow())
+            throw new RuntimeException("cp1364 failed on encode()/flush()/overflow!");
+    }
+}