1 /*
2 * Copyright 2001-2005 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26 import java.nio.CharBuffer;
27 import java.nio.ByteBuffer;
28 import java.nio.charset.*;
29 import sun.nio.cs.ext.EUC_TW;
30
31 public abstract class X11CNS11643 extends Charset {
32 private final int plane;
33 public X11CNS11643 (int plane, String name) {
34 super(name, null);
35 switch (plane) {
36 case 1:
37 this.plane = 0; // CS1
38 break;
39 case 2:
40 case 3:
41 this.plane = plane;
42 break;
43 default:
44 throw new IllegalArgumentException
45 ("Only planes 1, 2, and 3 supported");
46 }
47 }
48
49 public CharsetEncoder newEncoder() {
50 return new Encoder(this, plane);
51 }
52
53 public CharsetDecoder newDecoder() {
54 return new Decoder(this, plane);
55 }
56
57 public boolean contains(Charset cs) {
58 return cs instanceof X11CNS11643;
59 }
60
61 private class Encoder extends EUC_TW_OLD.Encoder {
62 private int plane;
63 public Encoder(Charset cs, int plane) {
64 super(cs);
65 this.plane = plane;
66 }
67 public boolean canEncode(char c) {
68 if (c <= 0x7F) {
69 return false;
70 }
71 int p = getNative(c) >> 16;
72 if (p == 1 && plane == 0 ||
73 p == 2 && plane == 2 ||
74 p == 3 && plane == 3)
75 return true;
76 return false;
77 }
78
79 public boolean isLegalReplacement(byte[] repl) {
80 return true;
81 }
82
83 protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {
84 char[] sa = src.array();
85 int sp = src.arrayOffset() + src.position();
86 int sl = src.arrayOffset() + src.limit();
87 byte[] da = dst.array();
88 int dp = dst.arrayOffset() + dst.position();
89 int dl = dst.arrayOffset() + dst.limit();
90
91 try {
92 while (sp < sl) {
93 char c = sa[sp];
94 if (c >= '\uFFFE' || c <= '\u007f')
95 return CoderResult.unmappableForLength(1);
96 int cns = getNative(c);
97 int p = cns >> 16;
98 if (p == 1 && plane == 0 ||
99 p == 2 && plane == 2 ||
100 p == 3 && plane == 3) {
101 if (dl - dp < 2)
102 return CoderResult.OVERFLOW;
103 da[dp++] = (byte) ((cns >> 8) & 0x7f);
104 da[dp++] = (byte) (cns & 0x7f);
105 sp++;
106 continue;
107 }
108 return CoderResult.unmappableForLength(1);
109 }
110 return CoderResult.UNDERFLOW;
111 } finally {
112 src.position(sp - src.arrayOffset());
113 dst.position(dp - dst.arrayOffset());
114 }
115 }
116 }
117
118 private class Decoder extends EUC_TW_OLD.Decoder {
119 private String table;
120 protected Decoder(Charset cs, int plane) {
121 super(cs);
122 switch (plane) {
123 case 0:
124 table = unicodeCNS1;
125 break;
126 case 2:
127 table = unicodeCNS2;
128 break;
129 case 3:
130 table = unicodeCNS3;
131 break;
132 default:
133 throw new IllegalArgumentException
134 ("Only planes 1, 2, and 3 supported");
135 }
136 }
137
138 //we only work on array backed buffer.
139 protected CoderResult decodeLoop(ByteBuffer src, CharBuffer dst) {
140 byte[] sa = src.array();
141 int sp = src.arrayOffset() + src.position();
142 int sl = src.arrayOffset() + src.limit();
143 assert (sp <= sl);
144 sp = (sp <= sl ? sp : sl);
145
146 char[] da = dst.array();
147 int dp = dst.arrayOffset() + dst.position();
148 int dl = dst.arrayOffset() + dst.limit();
149 assert (dp <= dl);
150 dp = (dp <= dl ? dp : dl);
151
152 try {
153 while (sp < sl) {
154 if ( sl - sp < 2) {
155 return CoderResult.UNDERFLOW;
156 }
157 byte b1 = sa[sp];
158 byte b2 = sa[sp + 1];
159 char c = replacement().charAt(0);
160
161 if (table == unicodeCNS3) {
162 char[] cc = convToSurrogate((byte)(b1 | 0x80),
163 (byte)(b2 | 0x80),
164 table);
165 if (cc != null && cc[0] == '\u0000')
166 c = cc[1];
167 } else {
168 c = convToUnicode((byte)(b1 | 0x80),
169 (byte)(b2 | 0x80),
170 table);
171 }
172 if (c == replacement().charAt(0)
173 //to keep the compatibility with b2cX11CNS11643
174 /*|| c == '\u0000'*/) {
175 return CoderResult.unmappableForLength(2);
176 }
177 if (dl - dp < 1)
178 return CoderResult.OVERFLOW;
179 da[dp++] = c;
180 sp +=2;
181 }
182 return CoderResult.UNDERFLOW;
183 } finally {
184 src.position(sp - src.arrayOffset());
185 dst.position(dp - dst.arrayOffset());
186 }
187 }
188 }
189 }