/*
* Copyright (c) 2001, 2003, 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.io;
import sun.nio.cs.ext.GB18030;
public class ByteToCharGB18030 extends ByteToCharGB18030DB {
private static final int GB18030_SINGLE_BYTE = 1;
private static final int GB18030_DOUBLE_BYTE = 2;
private static final int GB18030_FOUR_BYTE = 3;
private static short[] decoderIndex1;
private static String[] decoderIndex2;
private int currentState;
private int savedSize;
private byte[] savedBytes;
public ByteToCharGB18030() {
super();
GB18030 nioCoder = new GB18030();
savedBytes = new byte[3];
currentState = GB18030_DOUBLE_BYTE;
decoderIndex1 = nioCoder.getDecoderIndex1();
decoderIndex2 = nioCoder.getDecoderIndex2();
savedSize = 0;
}
public short[] getOuter() {
return(index1);
}
public String[] getInner() {
return(index2);
}
public short[] getDBIndex1() {
return(super.index1);
}
public String[] getDBIndex2() {
return(super.index2);
}
public int flush(char [] output, int outStart, int outEnd)
throws MalformedInputException
{
if (savedSize != 0) {
savedSize = 0;
currentState = GB18030_DOUBLE_BYTE;
badInputLength = 0;
throw new MalformedInputException();
}
byteOff = charOff = 0;
return 0;
}
/**
* Character conversion
*/
public int convert(byte[] input, int inOff, int inEnd,
char[] output, int outOff, int outEnd)
throws UnknownCharacterException, MalformedInputException,
ConversionBufferFullException
{
int inputSize = 0;
char outputChar = '\uFFFD';
// readOff keeps the actual buffer's pointer.
// byteOff keeps original buffer's pointer.
int readOff = byteOff = inOff;
if (savedSize != 0) {
// Filter illegal bytes when they are detected in saved
// partial input from a previous conversion attempt.
if (((savedBytes[0] & 0xFF) < 0x81 || savedBytes[0] > 0xFE) ||
(savedSize > 1 &&
(savedBytes[1] & 0xFF) < 0x30 ) ||
(savedSize > 2 &&
((savedBytes[2] & 0xFF) < 0x81 ||
(savedBytes[2] & 0xFF) > 0xFE ))) {
badInputLength = 0;
throw new MalformedInputException();
}
byte[] newBuf = new byte[inEnd - inOff + savedSize];
for (int i = 0; i < savedSize; i++) {
newBuf[i] = savedBytes[i];
}
System.arraycopy(input, inOff, newBuf, savedSize, inEnd - inOff);
byteOff -= savedSize;
input = newBuf;
inOff = 0;
inEnd = newBuf.length;
savedSize = 0;
}
charOff = outOff;
readOff = inOff;
while(readOff < inEnd) {
int byte1 = 0 , byte2 = 0, byte3 = 0, byte4 = 0;
// Is there room in the output buffer for the result?
if (charOff >= outEnd) {
throw new ConversionBufferFullException();
}
// Get the input byte
byte1 = input[readOff++] & 0xFF;
inputSize = 1;
if ((byte1 & (byte)0x80) == 0){ // US-ASCII range
outputChar = (char)byte1;
currentState = GB18030_SINGLE_BYTE;
}
else if (byte1 < 0x81 || byte1 > 0xfe) {
if (subMode)
outputChar = subChars[0];
else {
badInputLength = 1;
throw new UnknownCharacterException();
}
}
else {
// Either 2 or 4 byte sequence follows
// If an underrun is detected save for later
// replay.
if (readOff + inputSize > inEnd) {
savedBytes[0]=(byte)byte1;
savedSize = 1;
break;
}
byte2 = input[readOff++] & 0xFF;
inputSize = 2;
if (byte2 < 0x30) {
badInputLength = 1;
throw new MalformedInputException();
}
else if (byte2 >= 0x30 && byte2 <= 0x39) {
currentState = GB18030_FOUR_BYTE;
inputSize = 4;
if (readOff + 2 > inEnd) {
if (readOff + 1 > inEnd) {
savedBytes[0] = (byte)byte1;
savedBytes[1] = (byte)byte2;
savedSize = 2;
}
else {
savedBytes[0] = (byte)byte1;
savedBytes[1] = (byte)byte2;
savedBytes[2] = input[readOff++];
savedSize = 3;
}
break;
}
byte3 = input[readOff++] & 0xFF;
if (byte3 < 0x81 || byte3 > 0xfe) {
badInputLength = 3;
throw new MalformedInputException();
}
byte4 = input[readOff++] & 0xFF;
if (byte4 < 0x30 || byte4 > 0x39) {
badInputLength = 4;
throw new MalformedInputException();
}
}
else if (byte2 == 0x7f || byte2 == 0xff ||
(byte2 < 0x40 )) {
badInputLength = 2;
throw new MalformedInputException();
}
else
currentState = GB18030_DOUBLE_BYTE;
}
switch (currentState){
case GB18030_SINGLE_BYTE:
output[charOff++] = (char)(byte1);
break;
case GB18030_DOUBLE_BYTE:
output[charOff++] = super.getUnicode(byte1, byte2);
break;
case GB18030_FOUR_BYTE:
int offset = (((byte1 - 0x81) * 10 +
(byte2 - 0x30)) * 126 +
byte3 - 0x81) * 10 + byte4 - 0x30;
int hiByte = (offset >>8) & 0xFF;
int lowByte = (offset & 0xFF);
// Mixture of table lookups and algorithmic calculation
// of character values.
// BMP Ranges
if (offset <= 0x4A62)
output[charOff++] = getChar(offset);
else if (offset > 0x4A62 && offset <= 0x82BC)
output[charOff++] = (char) (offset + 0x5543);
else if (offset >= 0x82BD && offset <= 0x830D)
output[charOff++] = getChar(offset);
else if (offset >= 0x830D && offset <= 0x93A8)
output[charOff++] = (char) (offset + 0x6557);
else if (offset >= 0x93A9 && offset <= 0x99FB)
output[charOff++] = getChar(offset);
// Supplemental UCS planes handled via surrogates
else if (offset >= 0x2E248 && offset < 0x12E248) {
if (offset >= 0x12E248) {
if (subMode)
return subChars[0];
else {
badInputLength = 4;
throw new UnknownCharacterException();
}
}
if (charOff +2 > outEnd) {
throw new ConversionBufferFullException();
}
offset -= 0x1e248;
char highSurr = (char) ((offset - 0x10000) / 0x400 + 0xD800);
char lowSurr = (char) ((offset - 0x10000) % 0x400 + 0xDC00);
output[charOff++] = highSurr;
output[charOff++] = lowSurr;
}
else {
badInputLength = 4;
throw new MalformedInputException();
}
break;
}
byteOff += inputSize;
}
byteOff += savedSize;
return charOff - outOff;
}
public void reset() {
byteOff = charOff = 0;
currentState = GB18030_DOUBLE_BYTE;
savedSize = 0;
}
public String getCharacterEncoding() {
return "GB18030";
}
private char getChar(int offset) throws UnknownCharacterException {
int byte1 = (offset >>8) & 0xFF;
int byte2 = (offset & 0xFF);
int start = 0, end = 0xFF;
if (((byte1 < 0) || (byte1 > getOuter().length))
|| ((byte2 < start) || (byte2 > end))) {
if (subMode)
return subChars[0];
else {
badInputLength = 1;
throw new UnknownCharacterException();
}
}
int n = (decoderIndex1[byte1] & 0xf) * (end - start + 1) + (byte2 - start);
return decoderIndex2[decoderIndex1[byte1] >> 4].charAt(n);
}
}