ByteToCharUnicode.java

/*
 * Copyright (c) 1996, 1999, 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 java.io.*;


/**
 * Convert byte arrays containing Unicode characters into arrays of actual
 * Unicode characters.  This class may be used directly, in which case it
 * expects the input byte array to begin with a byte-order mark, or it may be
 * subclassed in order to preset the byte order and mark behavior.
 *
 * <p> Whether or not a mark is expected, if a mark that does not match the
 * established byte order is later discovered then a
 * <tt>MalformedInputException</tt> will be thrown by the <tt>convert</tt>
 * method.  If a correct mark is seen later in the input stream, it is passed
 * through as a character.
 *
 * @see ByteToCharUnicodeLittle
 * @see ByteToCharUnicodeLittleUnmarked
 * @see ByteToCharUnicodeBig
 * @see ByteToCharUnicodeBigUnmarked
 *
 * @author	Mark Reinhold
 */

public class ByteToCharUnicode extends ByteToCharConverter {

    static final char BYTE_ORDER_MARK = (char) 0xfeff;
    static final char REVERSED_MARK = (char) 0xfffe;

    static final int AUTO = 0;
    static final int BIG = 1;
    static final int LITTLE = 2;

    int originalByteOrder;	/* Byte order specified at creation */
    int byteOrder;		/* Byte order in use */
    boolean usesMark;		/* Look for a mark and interpret it */

    /**
     * Creates a Unicode byte-to-char converter that expects the first pair of
     * input bytes to be a byte-order mark, which will be interpreted and
     * discarded.  If the first pair of bytes is not such a mark then a
     * <tt>MalformedInputException</tt> will be thrown by the convert method.
     */
    public ByteToCharUnicode() {
	originalByteOrder = byteOrder = AUTO;
	usesMark = true;
    }

    /**
     * Creates a Unicode byte-to-char converter that uses the given byte order
     * and may or may not insist upon an initial byte-order mark.
     */
    protected ByteToCharUnicode(int bo, boolean m) {
	originalByteOrder = byteOrder = bo;
	usesMark = m;
    }

    public String getCharacterEncoding() {
	switch (originalByteOrder) {
	case BIG:
	    return usesMark ? "UnicodeBig" : "UnicodeBigUnmarked";
	case LITTLE:
	    return usesMark ? "UnicodeLittle" : "UnicodeLittleUnmarked";
	default:
	    return "Unicode";
	}
    }

    boolean started = false;
    int leftOverByte;
    boolean leftOver = false;

    public int convert(byte[] in, int inOff, int inEnd,
		       char[] out, int outOff, int outEnd)
	throws ConversionBufferFullException, MalformedInputException
    {
	byteOff = inOff;
	charOff = outOff;

	if (inOff >= inEnd)
	    return 0;

	int b1, b2;
	int bc = 0;
	int inI = inOff, outI = outOff;

	if (leftOver) {
	    b1 = leftOverByte & 0xff;
	    leftOver = false;
	}
	else {
	    b1 = in[inI++] & 0xff;
	}
	bc = 1;

	if (usesMark && !started) {	/* Read initial byte-order mark */
	    if (inI < inEnd) {
		b2 = in[inI++] & 0xff;
		bc = 2;

		char c = (char) ((b1 << 8) | b2);
		int bo = AUTO;

		if (c == BYTE_ORDER_MARK)
		    bo = BIG;
		else if (c == REVERSED_MARK)
		    bo = LITTLE;

		if (byteOrder == AUTO) {
		    if (bo == AUTO) {
			badInputLength = bc;
			throw new
			    MalformedInputException("Missing byte-order mark");
		    }
		    byteOrder = bo;
		    if (inI < inEnd) {
			b1 = in[inI++] & 0xff;
			bc = 1;
		    }
		}
		else if (bo == AUTO) {
		    inI--;
		    bc = 1;
		}
		else if (byteOrder == bo) {
		    if (inI < inEnd) {
			b1 = in[inI++] & 0xff;
			bc = 1;
		    }
		}
		else {
		    badInputLength = bc;
		    throw new
			MalformedInputException("Incorrect byte-order mark");
		}

		started = true;
	    }
	}

	/* Loop invariant: (b1 contains the next input byte) && (bc == 1) */
	while (inI < inEnd) {
	    b2 = in[inI++] & 0xff;
	    bc = 2;

	    char c;
	    if (byteOrder == BIG)
		c = (char) ((b1 << 8) | b2);
	    else
		c = (char) ((b2 << 8) | b1);

	    if (c == REVERSED_MARK)
		throw new
		    MalformedInputException("Reversed byte-order mark");

	    if (outI >= outEnd)
		throw new ConversionBufferFullException();
	    out[outI++] = c;
	    byteOff = inI;
	    charOff = outI;

	    if (inI < inEnd) {
		b1 = in[inI++] & 0xff;
		bc = 1;
	    }
	}

	if (bc == 1) {
	    leftOverByte = b1;	
	    byteOff = inI;
	    leftOver = true;
	}

	return outI - outOff;
    }

    public void reset() {
	leftOver = false;
	byteOff = charOff = 0;
	started = false;
	byteOrder = originalByteOrder;
    }

    public int flush(char buf[], int off, int len)
	throws MalformedInputException
    {
	if (leftOver) {
	    reset();
	    throw new MalformedInputException();
	}
	byteOff = charOff = 0;
	return 0;
    }

}