Back to index...

	/*
	* Copyright (c) 2009, 2010, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	package sun.nio.cs.ext;

	import java.io.*;
	import java.nio.CharBuffer;
	import java.nio.ByteBuffer;
	import java.nio.charset.Charset;
	import java.nio.charset.CharsetDecoder;
	import java.nio.charset.CharsetEncoder;
	import java.nio.charset.CoderResult;
	import java.util.Arrays;
	import sun.nio.cs.HistoricallyNamedCharset;
	import static sun.nio.cs.CharsetMapping.*;

	public class EUC_TW extends Charset implements HistoricallyNamedCharset
	{
	private static final int SS2 = 0x8E;

	/*
	(1) EUC_TW
	Second byte of EUC_TW for cs2 is in range of
	0xA1-0xB0 for plane 1-16. According to CJKV /163,
	plane1 is coded in both cs1 and cs2. This impl
	however does not decode the codepoints of plane1
	in cs2, so only p2-p7 and p15 are supported in cs2.

	Plane2 0xA2;
	Plane3 0xA3;
	Plane4 0xA4;
	Plane5 0xA5;
	Plane6 0xA6;
	Plane7 0xA7;
	Plane15 0xAF;

	(2) Mapping
	The fact that all supplementary characters encoded in EUC_TW are
	in 0x2xxxx range gives us the room to optimize the data tables.

	Decoding:
	(1) save the lower 16-bit value of all codepoints of b->c mapping
	in a String array table String[plane] b2c.
	(2) save "codepoint is supplementary" info (one bit) in a
	byte[] b2cIsSupp, so 8 codepoints (same codepoint value, different
	plane No) share one byte.

	Encoding:
	(1)c->b mappings are stored in
	char[]c2b/char[]c2bIndex
	char[]c2bSupp/char[]c2bIndexsupp (indexed by lower 16-bit
	(2)byte[] c2bPlane stores the "plane info" of each euc-tw codepoints,
	BMP and Supp share the low/high 4 bits of one byte.

	Mapping tables are stored separated in EUC_TWMapping, which
	is generated by tool.
	*/

	public EUC_TW() {
	super("x-EUC-TW", ExtendedCharsets.aliasesFor("x-EUC-TW"));
	}

	public String historicalName() {
	return "EUC_TW";
	}

	public boolean contains(Charset cs) {
	return ((cs.name().equals("US-ASCII"))
	\|\| (cs instanceof EUC_TW));
	}

	public CharsetDecoder newDecoder() {
	return new Decoder(this);
	}

	public CharsetEncoder newEncoder() {
	return new Encoder(this);
	}

	public static class Decoder extends CharsetDecoder {
	public Decoder(Charset cs) {
	super(cs, 2.0f, 2.0f);
	}

	char[] c1 = new char[1];
	char[] c2 = new char[2];
	public char[] toUnicode(int b1, int b2, int p) {
	return decode(b1, b2, p, c1, c2);
	}

	static final String[] b2c = EUC_TWMapping.b2c;
	static final int b1Min = EUC_TWMapping.b1Min;
	static final int b1Max = EUC_TWMapping.b1Max;
	static final int b2Min = EUC_TWMapping.b2Min;
	static final int b2Max = EUC_TWMapping.b2Max;
	static final int dbSegSize = b2Max - b2Min + 1;
	static final byte[] b2cIsSupp;

	// adjust from cns planeNo to the plane index of b2c
	static final byte[] cnspToIndex = new byte[0x100];
	static {
	Arrays.fill(cnspToIndex, (byte)-1);
	cnspToIndex[0xa2] = 1; cnspToIndex[0xa3] = 2; cnspToIndex[0xa4] = 3;
	cnspToIndex[0xa5] = 4; cnspToIndex[0xa6] = 5; cnspToIndex[0xa7] = 6;
	cnspToIndex[0xaf] = 7;
	}

	//static final BitSet b2cIsSupp;
	static {
	String b2cIsSuppStr = EUC_TWMapping.b2cIsSuppStr;
	// work on a local copy is much faster than operate
	// directly on b2cIsSupp
	byte[] flag = new byte[b2cIsSuppStr.length() << 1];
	int off = 0;
	for (int i = 0; i < b2cIsSuppStr.length(); i++) {
	char c = b2cIsSuppStr.charAt(i);
	flag[off++] = (byte)(c >> 8);
	flag[off++] = (byte)(c & 0xff);
	}
	b2cIsSupp = flag;
	}

	static boolean isLegalDB(int b) {
	return b >= b1Min && b <= b1Max;
	}

	static char[] decode(int b1, int b2, int p, char[] c1, char[] c2)
	{
	if (b1 < b1Min \|\| b1 > b1Max \|\| b2 < b2Min \|\| b2 > b2Max)
	return null;
	int index = (b1 - b1Min) * dbSegSize + b2 - b2Min;
	char c = b2c[p].charAt(index);
	if (c == UNMAPPABLE_DECODING)
	return null;
	if ((b2cIsSupp[index] & (1 << p)) == 0) {
	c1[0] = c;
	return c1;
	} else {
	c2[0] = Character.highSurrogate(0x20000 + c);
	c2[1] = Character.lowSurrogate(0x20000 + c);
	return c2;
	}
	}

	private CoderResult decodeArrayLoop(ByteBuffer src,
	CharBuffer dst)
	{
	byte[] sa = src.array();
	int sp = src.arrayOffset() + src.position();
	int sl = src.arrayOffset() + src.limit();

	char[] da = dst.array();
	int dp = dst.arrayOffset() + dst.position();
	int dl = dst.arrayOffset() + dst.limit();
	try {
	while (sp < sl) {
	int byte1 = sa[sp] & 0xff;
	if (byte1 == SS2) { // Codeset 2 G2
	if ( sl - sp < 4)
	return CoderResult.UNDERFLOW;
	int cnsPlane = cnspToIndex[sa[sp + 1] & 0xff];
	if (cnsPlane < 0)
	return CoderResult.malformedForLength(2);
	byte1 = sa[sp + 2] & 0xff;
	int byte2 = sa[sp + 3] & 0xff;
	char[] cc = toUnicode(byte1, byte2, cnsPlane);
	if (cc == null) {
	if (!isLegalDB(byte1) \|\| !isLegalDB(byte2))
	return CoderResult.malformedForLength(4);
	return CoderResult.unmappableForLength(4);
	}
	if (dl - dp < cc.length)
	return CoderResult.OVERFLOW;
	if (cc.length == 1) {
	da[dp++] = cc[0];
	} else {
	da[dp++] = cc[0];
	da[dp++] = cc[1];
	}
	sp += 4;
	} else if (byte1 < 0x80) { // ASCII G0
	if (dl - dp < 1)
	return CoderResult.OVERFLOW;
	da[dp++] = (char) byte1;
	sp++;
	} else { // Codeset 1 G1
	if ( sl - sp < 2)
	return CoderResult.UNDERFLOW;
	int byte2 = sa[sp + 1] & 0xff;
	char[] cc = toUnicode(byte1, byte2, 0);
	if (cc == null) {
	if (!isLegalDB(byte1) \|\| !isLegalDB(byte2))
	return CoderResult.malformedForLength(1);
	return CoderResult.unmappableForLength(2);
	}
	if (dl - dp < 1)
	return CoderResult.OVERFLOW;
	da[dp++] = cc[0];
	sp += 2;
	}
	}
	return CoderResult.UNDERFLOW;
	} finally {
	src.position(sp - src.arrayOffset());
	dst.position(dp - dst.arrayOffset());
	}
	}

	private CoderResult decodeBufferLoop(ByteBuffer src,
	CharBuffer dst)
	{
	int mark = src.position();
	try {
	while (src.hasRemaining()) {
	int byte1 = src.get() & 0xff;
	if (byte1 == SS2) { // Codeset 2 G2
	if ( src.remaining() < 3)
	return CoderResult.UNDERFLOW;
	int cnsPlane = cnspToIndex[src.get() & 0xff];
	if (cnsPlane < 0)
	return CoderResult.malformedForLength(2);
	byte1 = src.get() & 0xff;
	int byte2 = src.get() & 0xff;
	char[] cc = toUnicode(byte1, byte2, cnsPlane);
	if (cc == null) {
	if (!isLegalDB(byte1) \|\| !isLegalDB(byte2))
	return CoderResult.malformedForLength(4);
	return CoderResult.unmappableForLength(4);
	}
	if (dst.remaining() < cc.length)
	return CoderResult.OVERFLOW;
	if (cc.length == 1) {
	dst.put(cc[0]);
	} else {
	dst.put(cc[0]);
	dst.put(cc[1]);
	}
	mark += 4;
	} else if (byte1 < 0x80) { // ASCII G0
	if (!dst.hasRemaining())
	return CoderResult.OVERFLOW;
	dst.put((char) byte1);
	mark++;
	} else { // Codeset 1 G1
	if (!src.hasRemaining())
	return CoderResult.UNDERFLOW;
	int byte2 = src.get() & 0xff;
	char[] cc = toUnicode(byte1, byte2, 0);
	if (cc == null) {
	if (!isLegalDB(byte1) \|\| !isLegalDB(byte2))
	return CoderResult.malformedForLength(1);
	return CoderResult.unmappableForLength(2);
	}
	if (!dst.hasRemaining())
	return CoderResult.OVERFLOW;
	dst.put(cc[0]);
	mark +=2;
	}
	}
	return CoderResult.UNDERFLOW;
	} finally {
	src.position(mark);
	}
	}

	protected CoderResult decodeLoop(ByteBuffer src, CharBuffer dst)
	{
	if (src.hasArray() && dst.hasArray())
	return decodeArrayLoop(src, dst);
	else
	return decodeBufferLoop(src, dst);
	}
	}

	public static class Encoder extends CharsetEncoder {
	private byte[] bb = new byte[4];

	public Encoder(Charset cs) {
	super(cs, 4.0f, 4.0f);
	}

	public boolean canEncode(char c) {
	return (c <= '\u007f' \|\| toEUC(c, bb) != -1);
	}

	public boolean canEncode(CharSequence cs) {
	int i = 0;
	while (i < cs.length()) {
	char c = cs.charAt(i++);
	if (Character.isHighSurrogate(c)) {
	if (i == cs.length())
	return false;
	char low = cs.charAt(i++);
	if (!Character.isLowSurrogate(low) \|\| toEUC(c, low, bb) == -1)
	return false;
	} else if (!canEncode(c)) {
	return false;
	}
	}
	return true;
	}

	public int toEUC(char hi, char low, byte[] bb) {
	return encode(hi, low, bb);
	}

	public int toEUC(char c, byte[] bb) {
	return encode(c, bb);
	}

	private CoderResult encodeArrayLoop(CharBuffer src,
	ByteBuffer dst)
	{
	char[] sa = src.array();
	int sp = src.arrayOffset() + src.position();
	int sl = src.arrayOffset() + src.limit();

	byte[] da = dst.array();
	int dp = dst.arrayOffset() + dst.position();
	int dl = dst.arrayOffset() + dst.limit();

	int inSize;
	int outSize;

	try {
	while (sp < sl) {
	char c = sa[sp];
	inSize = 1;
	if (c < 0x80) { // ASCII
	bb[0] = (byte)c;
	outSize = 1;
	} else {
	outSize = toEUC(c, bb);
	if (outSize == -1) {
	// to check surrogates only after BMP failed
	// has the benefit of improving the BMP encoding
	// 10% faster, with the price of the slowdown of
	// supplementary character encoding. given the use
	// of supplementary characters is really rare, this
	// is something worth doing.
	if (Character.isHighSurrogate(c)) {
	if ((sp + 1) == sl)
	return CoderResult.UNDERFLOW;
	if (!Character.isLowSurrogate(sa[sp + 1]))
	return CoderResult.malformedForLength(1);
	outSize = toEUC(c, sa[sp+1], bb);
	inSize = 2;
	} else if (Character.isLowSurrogate(c)) {
	return CoderResult.malformedForLength(1);
	}
	}
	}
	if (outSize == -1)
	return CoderResult.unmappableForLength(inSize);
	if ( dl - dp < outSize)
	return CoderResult.OVERFLOW;
	for (int i = 0; i < outSize; i++)
	da[dp++] = bb[i];
	sp += inSize;
	}
	return CoderResult.UNDERFLOW;
	} finally {
	src.position(sp - src.arrayOffset());
	dst.position(dp - dst.arrayOffset());
	}
	}

	private CoderResult encodeBufferLoop(CharBuffer src,
	ByteBuffer dst)
	{
	int outSize;
	int inSize;
	int mark = src.position();

	try {
	while (src.hasRemaining()) {
	inSize = 1;
	char c = src.get();
	if (c < 0x80) { // ASCII
	outSize = 1;
	bb[0] = (byte)c;
	} else {
	outSize = toEUC(c, bb);
	if (outSize == -1) {
	if (Character.isHighSurrogate(c)) {
	if (!src.hasRemaining())
	return CoderResult.UNDERFLOW;
	char c2 = src.get();
	if (!Character.isLowSurrogate(c2))
	return CoderResult.malformedForLength(1);
	outSize = toEUC(c, c2, bb);
	inSize = 2;
	} else if (Character.isLowSurrogate(c)) {
	return CoderResult.malformedForLength(1);
	}
	}
	}
	if (outSize == -1)
	return CoderResult.unmappableForLength(inSize);
	if (dst.remaining() < outSize)
	return CoderResult.OVERFLOW;
	for (int i = 0; i < outSize; i++)
	dst.put(bb[i]);
	mark += inSize;
	}
	return CoderResult.UNDERFLOW;
	} finally {
	src.position(mark);
	}
	}

	protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst)
	{
	if (src.hasArray() && dst.hasArray())
	return encodeArrayLoop(src, dst);
	else
	return encodeBufferLoop(src, dst);
	}

	static int encode(char hi, char low, byte[] bb) {
	int c = Character.toCodePoint(hi, low);
	if ((c & 0xf0000) != 0x20000)
	return -1;
	c -= 0x20000;
	int index = c2bSuppIndex[c >> 8];
	if (index == UNMAPPABLE_ENCODING)
	return -1;
	index = index + (c & 0xff);
	int db = c2bSupp[index];
	if (db == UNMAPPABLE_ENCODING)
	return -1;
	int p = (c2bPlane[index] >> 4) & 0xf;
	bb[0] = (byte)SS2;
	bb[1] = (byte)(0xa0 \| p);
	bb[2] = (byte)(db >> 8);
	bb[3] = (byte)db;
	return 4;
	}

	static int encode(char c, byte[] bb) {
	int index = c2bIndex[c >> 8];
	if (index == UNMAPPABLE_ENCODING)
	return -1;
	index = index + (c & 0xff);
	int db = c2b[index];
	if (db == UNMAPPABLE_ENCODING)
	return -1;
	int p = c2bPlane[index] & 0xf;
	if (p == 0) {
	bb[0] = (byte)(db >> 8);
	bb[1] = (byte)db;
	return 2;
	} else {
	bb[0] = (byte)SS2;
	bb[1] = (byte)(0xa0 \| p);
	bb[2] = (byte)(db >> 8);
	bb[3] = (byte)db;
	return 4;
	}
	}

	static final char[] c2b;
	static final char[] c2bIndex;
	static final char[] c2bSupp;
	static final char[] c2bSuppIndex;
	static final byte[] c2bPlane;
	static {
	int b1Min = Decoder.b1Min;
	int b1Max = Decoder.b1Max;
	int b2Min = Decoder.b2Min;
	int b2Max = Decoder.b2Max;
	int dbSegSize = Decoder.dbSegSize;
	String[] b2c = Decoder.b2c;
	byte[] b2cIsSupp = Decoder.b2cIsSupp;

	c2bIndex = EUC_TWMapping.c2bIndex;
	c2bSuppIndex = EUC_TWMapping.c2bSuppIndex;
	char[] c2b0 = new char[EUC_TWMapping.C2BSIZE];
	char[] c2bSupp0 = new char[EUC_TWMapping.C2BSUPPSIZE];
	byte[] c2bPlane0 = new byte[Math.max(EUC_TWMapping.C2BSIZE,
	EUC_TWMapping.C2BSUPPSIZE)];

	Arrays.fill(c2b0, (char)UNMAPPABLE_ENCODING);
	Arrays.fill(c2bSupp0, (char)UNMAPPABLE_ENCODING);

	for (int p = 0; p < b2c.length; p++) {
	String db = b2c[p];
	/*
	adjust the "plane" from 0..7 to 0, 2, 3, 4, 5, 6, 7, 0xf,
	which helps balance between footprint (to save the plane
	info in 4 bits) and runtime performance (to require only
	one operation "0xa0 \| plane" to encode the plane byte)
	*/
	int plane = p;
	if (plane == 7)
	plane = 0xf;
	else if (plane != 0)
	plane = p + 1;

	int off = 0;
	for (int b1 = b1Min; b1 <= b1Max; b1++) {
	for (int b2 = b2Min; b2 <= b2Max; b2++) {
	char c = db.charAt(off);
	if (c != UNMAPPABLE_DECODING) {
	if ((b2cIsSupp[off] & (1 << p)) != 0) {
	int index = c2bSuppIndex[c >> 8] + (c&0xff);
	c2bSupp0[index] = (char)((b1 << 8) + b2);
	c2bPlane0[index] \|= (byte)(plane << 4);
	} else {
	int index = c2bIndex[c >> 8] + (c&0xff);
	c2b0[index] = (char)((b1 << 8) + b2);
	c2bPlane0[index] \|= (byte)plane;
	}
	}
	off++;
	}
	}
	}
	c2b = c2b0;
	c2bSupp = c2bSupp0;
	c2bPlane = c2bPlane0;
	}
	}
	}

Back to index...