ojluni/src/main/java/sun/io/ByteToCharGB18030.java - platform/libcore.git - Git at Google

 /*
  * 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);
     }
 }
	/*
	* 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);
	}
	}