gcc/libjava/java/io/DataInputStream.java

/* Copyright (C) 1998, 1999  Cygnus Solutions

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */
 
package java.io;

/**
 * @author Warren Levy <warrenl@cygnus.com>
 * @date October 20, 1998.  
 */

/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
 * "The Java Language Specification", ISBN 0-201-63451-1
 * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
 * Status:  Believed complete and correct.
 */
 
public class DataInputStream extends FilterInputStream implements DataInput
{
  public DataInputStream(InputStream in)
  {
    super(in);
  }

  public final int read(byte[] b) throws IOException
  {
    return super.read(b, 0, b.length);
  }

  public final int read(byte[] b, int off, int len) throws IOException
  {
    if (off < 0 || len < 0 || off + len > b.length)
      throw new ArrayIndexOutOfBoundsException();

    return super.read(b, off, len);
  }

  public final boolean readBoolean() throws IOException
  {
    return (readByte() != 0);
  }

  public final byte readByte() throws IOException
  {
    int i = read();
    if (i < 0)
      throw new EOFException();

    return (byte) i;
  }

  public final char readChar() throws IOException
  {
    return (char) ((readByte() << 8) | readUnsignedByte());
  }

  public final double readDouble() throws IOException
  {
    return Double.longBitsToDouble(readLong());
  }

  public final float readFloat() throws IOException
  {
    return Float.intBitsToFloat(readInt());
  }

  public final void readFully(byte[] b) throws IOException
  {
    readFully(b, 0, b.length);
  }

  public final void readFully(byte[] b, int off, int len) throws IOException
  {
    if (off < 0 || len < 0 || off + len > b.length)
      throw new ArrayIndexOutOfBoundsException();

    while (len > 0)
      {
	// super.read will block until some data is available.
	int numread = super.read(b, off, len);
	if (numread < 0)
	  throw new EOFException();
	len -= numread;
	off += numread;
      }
  }

  public final int readInt() throws IOException
  {
    int retval = 0;
    for (int i = 0; i < 4; i++)
      retval |= readUnsignedByte() << (24 - i * 8);

    return retval;
  }

  // Deprecated as of JDK 1.1
  public final String readLine() throws IOException
  {
    StringBuffer strb = new StringBuffer();

    while (true)
      {
	int c = read();
	if (c < 0)	// got an EOF
	  return strb.length() > 0 ? strb.toString() : null;
	char ch = (char) c;
	if ((ch &= 0xFF) == '\n')
	  break;
	if (ch == '\r')
	  {
	    // FIXME: The following code tries to adjust the stream back one
	    // character if the next char read is '\n'.  As a last resort,
	    // it tries to mark the position before reading but the bottom
	    // line is that it is possible that this method will not properly
	    // deal with a '\r' '\n' combination thus not fulfilling the
	    // DataInput contract for readLine.  It's not a particularly
	    // safe approach threadwise since it is unsynchronized and
	    // since it might mark an input stream behind the users back.
	    // Along the same vein it could try the same thing for
	    // ByteArrayInputStream and PushbackInputStream, but that is
	    // probably overkill since this is deprecated & BufferedInputStream
	    // is the most likely type of input stream.
	    //
	    // The alternative is to somehow push back the next byte if it
	    // isn't a '\n' or to have the reading methods of this class
	    // keep track of whether the last byte read was '\r' by readLine
	    // and then skip the very next byte if it is '\n'.  Either way,
	    // this would increase the complexity of the non-deprecated methods
	    // and since it is undesirable to make non-deprecated methods
	    // less efficient, the following seems like the most reasonable
	    // approach.
	    if (in instanceof BufferedInputStream && (read() & 0xFF) != '\n')
	      {
	        BufferedInputStream bin = (BufferedInputStream) in;
		if (bin.pos > 0)
                  bin.pos--;
	      }
	    else if (markSupported())
	      {
		mark(1);
		if ((read() & 0xFF) != '\n')
		  reset();
	      }
	    break;
	  }
	strb.append(ch);
      }

    return strb.length() > 0 ? strb.toString() : "";
  }

  public final long readLong() throws IOException
  {
    long retval = 0L;
    for (int i = 0; i < 8; i++)
      retval |= (long) readUnsignedByte() << (56 - i * 8);

    return retval;
  }

  public final short readShort() throws IOException
  {
    return (short) ((readByte() << 8) | readUnsignedByte());
  }

  public final int readUnsignedByte() throws IOException
  {
    int i = read();
    if (i < 0)
      throw new EOFException();

    return (i & 0xFF);
  }

  public final int readUnsignedShort() throws IOException
  {
    return (readUnsignedByte() << 8) | readUnsignedByte();
  }

  public final String readUTF() throws IOException
  {
    return readUTF(this);
  }

  public final static String readUTF(DataInput in) throws IOException
  {
    final int UTFlen = in.readUnsignedShort();
    byte[] buf = new byte[UTFlen];
    StringBuffer strbuf = new StringBuffer();

    // This blocks until the entire string is available rather than
    // doing partial processing on the bytes that are available and then
    // blocking.  An advantage of the latter is that Exceptions
    // could be thrown earlier.  The former is a bit cleaner.
    in.readFully(buf, 0, UTFlen);
    for (int i = 0; i < UTFlen; )
      {
	if ((buf[i] & 0x80) == 0)		// bit pattern 0xxxxxxx
	  strbuf.append((char) (buf[i++] & 0xFF));
	else if ((buf[i] & 0xE0) == 0xC0)	// bit pattern 110xxxxx
	  {
	    if (i + 1 >= UTFlen || (buf[i+1] & 0xC0) != 0x80)
	      throw new UTFDataFormatException();

	    strbuf.append((char) (((buf[i++] & 0x1F) << 6) |
				  (buf[i++] & 0x3F)));
	  }
	else if ((buf[i] & 0xF0) == 0xE0)	// bit pattern 1110xxxx
	  {
	    if (i + 2 >= UTFlen ||
		(buf[i+1] & 0xC0) != 0x80 || (buf[i+2] & 0xC0) != 0x80)
	      throw new UTFDataFormatException();

	    strbuf.append((char) (((buf[i++] & 0x0F) << 12) |
				  ((buf[i++] & 0x3F) << 6) |
				  (buf[i++] & 0x3F)));
	  }
	else // must be ((buf[i] & 0xF0) == 0xF0 || (buf[i] & 0xC0) == 0x80)
	  throw new UTFDataFormatException();	// bit patterns 1111xxxx or
						// 		10xxxxxx
      }

    return strbuf.toString();
  }

  public final int skipBytes(int n) throws IOException
  {
    // The contract in the Java Lang. Spec. says that this never
    // throws an EOFException and infers that it doesn't block (since
    // it may skip less than the requested number of bytes).
    // BUT, the JCL book specifically says that this method blocks
    // and can throw an EOFException.  Finally, the Java 1.2 online
    // doc simply refers to the general contract.  As such, we will
    // stick to the contract and assume for now that the JCL book
    // is incorrect.

    // Since we're only skipping at most an int number of bytes, the cast
    // of return value to an int is fine.
    if (n > 0)
      {
	n = Math.min(n, available());
        return (int) super.skip((long) n);
      }

    return 0;
  }
}