[kaffe] CVS kaffe (robilad): Resynced with GNU Classpath: awt,
swing and io fixes
Kaffe CVS
cvs-commits at kaffe.org
Sun Jul 3 07:42:53 PDT 2005
PatchSet 6685
Date: 2005/07/03 14:37:51
Author: robilad
Branch: HEAD
Tag: (none)
Log:
Resynced with GNU Classpath: awt, swing and io fixes
Members:
ChangeLog:1.4210->1.4211
libraries/javalib/gnu/java/net/protocol/http/HTTPURLConnection.java:1.10->1.11
libraries/javalib/gnu/java/nio/charset/Windows1250.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1251.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1252.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1253.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1254.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1255.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1256.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1257.java:1.1->1.2
libraries/javalib/gnu/java/nio/charset/Windows1258.java:1.1->1.2
libraries/javalib/java/io/DataInputStream.java:INITIAL->1.25
libraries/javalib/javax/swing/DefaultListSelectionModel.java:1.7->1.8
libraries/javalib/javax/swing/JApplet.java:1.6->1.7
libraries/javalib/javax/swing/JDialog.java:1.4->1.5
libraries/javalib/javax/swing/JFrame.java:1.7->1.8
libraries/javalib/javax/swing/JInternalFrame.java:1.10->1.11
libraries/javalib/javax/swing/JList.java:1.10->1.11
libraries/javalib/javax/swing/JWindow.java:1.8->1.9
libraries/javalib/javax/swing/ToolTipManager.java:1.8->1.9
libraries/javalib/javax/swing/plaf/basic/BasicListUI.java:1.12->1.13
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4210 kaffe/ChangeLog:1.4211
--- kaffe/ChangeLog:1.4210 Sun Jul 3 14:14:53 2005
+++ kaffe/ChangeLog Sun Jul 3 14:37:51 2005
@@ -2,6 +2,82 @@
Resynced with GNU Classpath.
+ 2005-06-17 Anthony Balkissoon <abalkiss at redhat.com>
+
+ * javax/swing/JApplet.java,
+ javax/swing/JDialog.java,
+ javax/swing/JFrame.java,
+ javax/swing/JInternalFrame.java,
+ javax/swing/JWindow.java: Added support for adding and setting
+ layout managers directly for these top-level containers tocomply
+ with J2SE 5.0. Added private boolean initStageDone.
+ Initialized rootPaneCheckingEnabled to false.
+ (JDialog.dialogInit): Set initStageDone to true.
+ (JApplet.JApplet): Set initStageDone to true.
+ (JFrame.frameInit) : Set initStageDone to true.
+ (JInternalFrame.JInternalFrame): Set initStageDone to true.
+ (JWindow.windowInit): Set initStageDone to true.
+ (addImpl): Added check for direct adds (J2SE 5.0) and directed
+ them to getContentPane().add.
+ (setLayout): Added check for direct calls to setLayout.
+ (remove): Added check for direct calls to remove.
+
+ 2005-06-17 Lillian Angel <langel at redhat.com>
+
+ * javax/swing/ToolTipManager.java
+ (mousePressed): Check if currentComponent is null.
+ If so, it should be equal to the current source.
+ Fixes Bug #11538.
+
+ 2005-06-17 Anthony Balkissoon <abalkiss at redhat.com>
+
+ * javax/swing/DefaultListSelectionModel.java:
+ (addSelectionInterval): Added update to leadSelectionIndex
+ and anchorSelectionIndex variables.
+ (removeSelectionInterval): Same as above.
+ (setSelectionInterval): Same as above.
+ * javax/swing/JList.java:
+ (getSelectedIndices): Increased for loop upper bound by 1.
+ * javax/swing/plaf/basic/BasicListUI.java:
+ (KeyHandler): New class.
+ (MouseInputHandler): Moved code from MousePressed to
+ MouseClicked.
+ (MouseInputHandler.MouseClicked): Added check for control
+ key being down.
+
+ 2005-06-17 Roman Kennke <roman at kennke.org>
+
+ * java/io/DataInputStream.java:
+ Reverted my patch from 2005-06-15.
+
+ 2005-06-16 Robert Schuster <thebohemian at gmx.net>
+
+ * gnu/java/nio/charset/Windows1250.java,
+ gnu/java/nio/charset/Windows1251.java,
+ gnu/java/nio/charset/Windows1252.java,
+ gnu/java/nio/charset/Windows1253.java,
+ gnu/java/nio/charset/Windows1254.java,
+ gnu/java/nio/charset/Windows1255.java,
+ gnu/java/nio/charset/Windows1256.java,
+ gnu/java/nio/charset/Windows1257.java,
+ gnu/java/nio/charset/Windows1258.java: Fixed canonical NIO
+ charset name.
+
+ 2005-06-15 Goffredo Baroncelli <kreijack at inwind.it>
+
+ * gnu/java/net/protocol/http/HTTPURLConnection.java
+ (getHeaderFieldKey): Check index.
+
+ 2005-06-15 Roman Kennke <roman at kennke.org>
+
+ * java/io/DataInputStream.java
+ (readLine): Added checks for InputStream that support have a pos field
+ for repositioning the stream.
+
+2005-07-03 Dalibor Topic <robilad at kaffe.org>
+
+ Resynced with GNU Classpath.
+
2005-06-14 Mark Wielaard <mark at klomp.org>
* javax/swing/JComponent.java (setMinimumSize): Only adjust
Index: kaffe/libraries/javalib/gnu/java/net/protocol/http/HTTPURLConnection.java
diff -u kaffe/libraries/javalib/gnu/java/net/protocol/http/HTTPURLConnection.java:1.10 kaffe/libraries/javalib/gnu/java/net/protocol/http/HTTPURLConnection.java:1.11
--- kaffe/libraries/javalib/gnu/java/net/protocol/http/HTTPURLConnection.java:1.10 Mon May 30 01:17:01 2005
+++ kaffe/libraries/javalib/gnu/java/net/protocol/http/HTTPURLConnection.java Sun Jul 3 14:37:54 2005
@@ -1,5 +1,5 @@
/* HTTPURLConnection.java --
- Copyright (C) 2004 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -575,6 +575,10 @@
int count = 1;
do
{
+ if (!i.hasNext())
+ {
+ return null;
+ }
entry = (Map.Entry) i.next();
count++;
}
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1250.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1250.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1250.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1250.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1250.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1250()
{
- super("Windows-1250", new String[] {
+ super("windows-1250", new String[] {
"Windows1250",
"ibm-5346_P100-1998",
"ibm-5346",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1251.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1251.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1251.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1251.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1251.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1251()
{
- super("Windows-1251", new String[] {
+ super("windows-1251", new String[] {
"Windows1251",
"cp1251",
"cp-1251",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1252.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1252.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1252.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1252.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1252.java Sun Jul 3 14:37:55 2005
@@ -85,7 +85,7 @@
public Windows1252()
{
- super("Windows-1252", new String[] {
+ super("windows-1252", new String[] {
"Windows1252",
"ibm-5348_P100-1997",
"ibm-5348",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1253.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1253.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1253.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1253.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1253.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1253()
{
- super("Windows-1253", new String[] {
+ super("windows-1253", new String[] {
"Windows1253",
"cp1253",
"cp-1253",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1254.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1254.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1254.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1254.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1254.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1254()
{
- super("Windows-1254", new String[] {
+ super("windows-1254", new String[] {
"Windows1254",
"cp1254",
"cp-1254",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1255.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1255.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1255.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1255.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1255.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1255()
{
- super("Windows-1255", new String[] {
+ super("windows-1255", new String[] {
"Windows1255",
"cp1255",
"cp-1255",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1256.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1256.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1256.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1256.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1256.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1256()
{
- super("Windows-1256", new String[] {
+ super("windows-1256", new String[] {
"Windows1256",
"cp1256",
"cp-1256",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1257.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1257.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1257.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1257.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1257.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1257()
{
- super("Windows-1257", new String[] {
+ super("windows-1257", new String[] {
"Windows1257",
"cp1257",
"cp-1257",
Index: kaffe/libraries/javalib/gnu/java/nio/charset/Windows1258.java
diff -u kaffe/libraries/javalib/gnu/java/nio/charset/Windows1258.java:1.1 kaffe/libraries/javalib/gnu/java/nio/charset/Windows1258.java:1.2
--- kaffe/libraries/javalib/gnu/java/nio/charset/Windows1258.java:1.1 Tue Apr 19 10:12:23 2005
+++ kaffe/libraries/javalib/gnu/java/nio/charset/Windows1258.java Sun Jul 3 14:37:55 2005
@@ -86,7 +86,7 @@
public Windows1258()
{
- super("Windows-1258", new String[] {
+ super("windows-1258", new String[] {
"Windows1258",
"cp1258",
"cp-1258",
===================================================================
Checking out kaffe/libraries/javalib/java/io/DataInputStream.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/io/DataInputStream.java,v
VERS: 1.25
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/io/DataInputStream.java Sun Jul 3 14:42:52 2005
@@ -0,0 +1,739 @@
+/* DataInputStream.java -- FilteredInputStream that implements DataInput
+ Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package java.io;
+
+/* 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.
+ */
+
+/**
+ * This subclass of <code>FilteredInputStream</code> implements the
+ * <code>DataInput</code> interface that provides method for reading primitive
+ * Java data types from a stream.
+ *
+ * @see DataInput
+ *
+ * @author Warren Levy (warrenl at cygnus.com)
+ * @author Aaron M. Renn (arenn at urbanophile.com)
+ * @date October 20, 1998.
+ */
+public class DataInputStream extends FilterInputStream implements DataInput
+{
+ // Byte buffer, used to make primitive read calls more efficient.
+ byte[] buf = new byte [8];
+
+ /**
+ * This constructor initializes a new <code>DataInputStream</code>
+ * to read from the specified subordinate stream.
+ *
+ * @param in The subordinate <code>InputStream</code> to read from
+ */
+ public DataInputStream (InputStream in)
+ {
+ super (in);
+ }
+
+ /**
+ * This method reads bytes from the underlying stream into the specified
+ * byte array buffer. It will attempt to fill the buffer completely, but
+ * may return a short count if there is insufficient data remaining to be
+ * read to fill the buffer.
+ *
+ * @param b The buffer into which bytes will be read.
+ *
+ * @return The actual number of bytes read, or -1 if end of stream reached
+ * before reading any bytes.
+ *
+ * @exception IOException If an error occurs.
+ */
+ public final int read (byte[] b) throws IOException
+ {
+ return in.read (b, 0, b.length);
+ }
+
+ /**
+ * This method reads bytes from the underlying stream into the specified
+ * byte array buffer. It will attempt to read <code>len</code> bytes and
+ * will start storing them at position <code>off</code> into the buffer.
+ * This method can return a short count if there is insufficient data
+ * remaining to be read to complete the desired read length.
+ *
+ * @param b The buffer into which bytes will be read.
+ * @param off The offset into the buffer to start storing bytes.
+ * @param len The requested number of bytes to read.
+ *
+ * @return The actual number of bytes read, or -1 if end of stream reached
+ * before reading any bytes.
+ *
+ * @exception IOException If an error occurs.
+ */
+ public final int read (byte[] b, int off, int len) throws IOException
+ {
+ return in.read (b, off, len);
+ }
+
+ /**
+ * This method reads a Java boolean value from an input stream. It does
+ * so by reading a single byte of data. If that byte is zero, then the
+ * value returned is <code>false</code>. If the byte is non-zero, then
+ * the value returned is <code>true</code>.
+ * <p>
+ * This method can read a <code>boolean</code> written by an object
+ * implementing the <code>writeBoolean()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>boolean</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading
+ * the boolean
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeBoolean
+ */
+ public final boolean readBoolean () throws IOException
+ {
+ return convertToBoolean (in.read ());
+ }
+
+ /**
+ * This method reads a Java byte value from an input stream. The value
+ * is in the range of -128 to 127.
+ * <p>
+ * This method can read a <code>byte</code> written by an object
+ * implementing the <code>writeByte()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>byte</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading the byte
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeByte
+ */
+ public final byte readByte () throws IOException
+ {
+ return convertToByte (in.read ());
+ }
+
+ /**
+ * This method reads a Java <code>char</code> value from an input stream.
+ * It operates by reading two bytes from the stream and converting them to
+ * a single 16-bit Java <code>char</code>. The two bytes are stored most
+ * significant byte first (i.e., "big endian") regardless of the native
+ * host byte ordering.
+ * <p>
+ * As an example, if <code>byte1</code> and <code>byte2</code>
+ * represent the first and second byte read from the stream
+ * respectively, they will be transformed to a <code>char</code> in
+ * the following manner:
+ * <p>
+ * <code>(char)(((byte1 & 0xFF) << 8) | (byte2 & 0xFF)</code>
+ * <p>
+ * This method can read a <code>char</code> written by an object
+ * implementing the <code>writeChar()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>char</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading the char
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeChar
+ */
+ public final char readChar () throws IOException
+ {
+ readFully (buf, 0, 2);
+ return convertToChar (buf);
+ }
+
+ /**
+ * This method reads a Java double value from an input stream. It operates
+ * by first reading a <code>long</code> value from the stream by calling the
+ * <code>readLong()</code> method in this interface, then converts
+ * that <code>long</code> to a <code>double</code> using the
+ * <code>longBitsToDouble</code> method in the class
+ * <code>java.lang.Double</code>
+ * <p>
+ * This method can read a <code>double</code> written by an object
+ * implementing the <code>writeDouble()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>double</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading
+ * the double
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeDouble
+ * @see java.lang.Double#longBitsToDouble
+ */
+ public final double readDouble () throws IOException
+ {
+ return Double.longBitsToDouble (readLong ());
+ }
+
+ /**
+ * This method reads a Java float value from an input stream. It
+ * operates by first reading an <code>int</code> value from the
+ * stream by calling the <code>readInt()</code> method in this
+ * interface, then converts that <code>int</code> to a
+ * <code>float</code> using the <code>intBitsToFloat</code> method
+ * in the class <code>java.lang.Float</code>
+ * <p>
+ * This method can read a <code>float</code> written by an object
+ * implementing the <code>writeFloat()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>float</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading the float
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeFloat
+ * @see java.lang.Float#intBitsToFloat
+ */
+ public final float readFloat () throws IOException
+ {
+ return Float.intBitsToFloat (readInt ());
+ }
+
+ /**
+ * This method reads raw bytes into the passed array until the array is
+ * full. Note that this method blocks until the data is available and
+ * throws an exception if there is not enough data left in the stream to
+ * fill the buffer. Note also that zero length buffers are permitted.
+ * In this case, the method will return immediately without reading any
+ * bytes from the stream.
+ *
+ * @param b The buffer into which to read the data
+ *
+ * @exception EOFException If end of file is reached before filling the
+ * buffer
+ * @exception IOException If any other error occurs
+ */
+ public final void readFully (byte[] b) throws IOException
+ {
+ readFully (b, 0, b.length);
+ }
+
+ /**
+ * This method reads raw bytes into the passed array <code>buf</code>
+ * starting
+ * <code>offset</code> bytes into the buffer. The number of bytes read
+ * will be
+ * exactly <code>len</code>. Note that this method blocks until the data is
+ * available and throws an exception if there is not enough data left in
+ * the stream to read <code>len</code> bytes. Note also that zero length
+ * buffers are permitted. In this case, the method will return immediately
+ * without reading any bytes from the stream.
+ *
+ * @param buf The buffer into which to read the data
+ * @param offset The offset into the buffer to start storing data
+ * @param len The number of bytes to read into the buffer
+ *
+ * @exception EOFException If end of file is reached before filling the
+ * buffer
+ * @exception IOException If any other error occurs
+ */
+ public final void readFully (byte[] buf, int offset, int len) throws IOException
+ {
+ if (len < 0)
+ throw new IndexOutOfBoundsException("Negative length: " + len);
+
+ while (len > 0)
+ {
+ // in.read will block until some data is available.
+ int numread = in.read (buf, offset, len);
+ if (numread < 0)
+ throw new EOFException ();
+ len -= numread;
+ offset += numread;
+ }
+ }
+
+ /**
+ * This method reads a Java <code>int</code> value from an input stream
+ * It operates by reading four bytes from the stream and converting them to
+ * a single Java <code>int</code>. The bytes are stored most
+ * significant byte first (i.e., "big endian") regardless of the native
+ * host byte ordering.
+ * <p>
+ * As an example, if <code>byte1</code> through <code>byte4</code> represent
+ * the first four bytes read from the stream, they will be
+ * transformed to an <code>int</code> in the following manner:
+ * <p>
+ * <code>(int)(((byte1 & 0xFF) << 24) + ((byte2 & 0xFF) << 16) +
+ * ((byte3 & 0xFF)<< 8) + (byte4 & 0xFF)))</code>
+ * <p>
+ * The value returned is in the range of -2147483648 to 2147483647.
+ * <p>
+ * This method can read an <code>int</code> written by an object
+ * implementing the <code>writeInt()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>int</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading the int
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeInt
+ */
+ public final int readInt () throws IOException
+ {
+ readFully (buf, 0, 4);
+ return convertToInt (buf);
+ }
+
+ /**
+ * This method reads the next line of text data from an input
+ * stream. It operates by reading bytes and converting those bytes
+ * to <code>char</code> values by treating the byte read as the low
+ * eight bits of the <code>char</code> and using 0 as the high eight
+ * bits. Because of this, it does not support the full 16-bit
+ * Unicode character set.
+ * <p>
+ * The reading of bytes ends when either the end of file or a line
+ * terminator is encountered. The bytes read are then returned as a
+ * <code>String</code> A line terminator is a byte sequence
+ * consisting of either <code>\r</code>, <code>\n</code> or
+ * <code>\r\n</code>. These termination charaters are discarded and
+ * are not returned as part of the string.
+ * <p>
+ * This method can read data that was written by an object implementing the
+ * <code>writeLine()</code> method in <code>DataOutput</code>.
+ *
+ * @return The line read as a <code>String</code>
+ *
+ * @exception IOException If an error occurs
+ *
+ * @see DataOutput
+ *
+ * @deprecated
+ */
+ public final String readLine() throws IOException
+ {
+ StringBuffer strb = new StringBuffer();
+
+ while (true)
+ {
+ int c = in.read();
+ if (c == -1) // got an EOF
+ return strb.length() > 0 ? strb.toString() : null;
+ if (c == '\r')
+ {
+ int next_c = in.read();
+ if (next_c != '\n' && next_c != -1)
+ {
+ if (!(in instanceof PushbackInputStream))
+ in = new PushbackInputStream(in);
+ ((PushbackInputStream) in).unread(next_c);
+ }
+ break;
+ }
+ if (c == '\n')
+ break;
+ strb.append((char) c);
+ }
+
+ return strb.length() > 0 ? strb.toString() : "";
+ }
+
+ /**
+ * This method reads a Java <code>long</code> value from an input stream
+ * It operates by reading eight bytes from the stream and converting them to
+ * a single Java <code>long</code>. The bytes are stored most
+ * significant byte first (i.e., "big endian") regardless of the native
+ * host byte ordering.
+ * <p>
+ * As an example, if <code>byte1</code> through <code>byte8</code> represent
+ * the first eight bytes read from the stream, they will be
+ * transformed to an <code>long</code> in the following manner:
+ * <p>
+ * <code>(long)(((byte1 & 0xFF) << 56) + ((byte2 & 0xFF) << 48) +
+ * ((byte3 & 0xFF) << 40) + ((byte4 & 0xFF) << 32) +
+ * ((byte5 & 0xFF) << 24) + ((byte6 & 0xFF) << 16) +
+ * ((byte7 & 0xFF) << 8) + (byte8 & 0xFF)))
+ * </code>
+ * <p>
+ * The value returned is in the range of -9223372036854775808 to
+ * 9223372036854775807.
+ * <p>
+ * This method can read an <code>long</code> written by an object
+ * implementing the <code>writeLong()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>long</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading the long
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeLong
+ */
+ public final long readLong () throws IOException
+ {
+ readFully (buf, 0, 8);
+ return convertToLong (buf);
+ }
+
+ /**
+ * This method reads a signed 16-bit value into a Java in from the
+ * stream. It operates by reading two bytes from the stream and
+ * converting them to a single 16-bit Java <code>short</code>. The
+ * two bytes are stored most significant byte first (i.e., "big
+ * endian") regardless of the native host byte ordering.
+ * <p>
+ * As an example, if <code>byte1</code> and <code>byte2</code>
+ * represent the first and second byte read from the stream
+ * respectively, they will be transformed to a <code>short</code>. in
+ * the following manner:
+ * <p>
+ * <code>(short)(((byte1 & 0xFF) << 8) | (byte2 & 0xFF))</code>
+ * <p>
+ * The value returned is in the range of -32768 to 32767.
+ * <p>
+ * This method can read a <code>short</code> written by an object
+ * implementing the <code>writeShort()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The <code>short</code> value read
+ *
+ * @exception EOFException If end of file is reached before reading the value
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeShort
+ */
+ public final short readShort () throws IOException
+ {
+ readFully (buf, 0, 2);
+ return convertToShort (buf);
+ }
+
+ /**
+ * This method reads 8 unsigned bits into a Java <code>int</code>
+ * value from the stream. The value returned is in the range of 0 to
+ * 255.
+ * <p>
+ * This method can read an unsigned byte written by an object
+ * implementing the <code>writeUnsignedByte()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The unsigned bytes value read as a Java <code>int</code>.
+ *
+ * @exception EOFException If end of file is reached before reading the value
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeByte
+ */
+ public final int readUnsignedByte () throws IOException
+ {
+ return convertToUnsignedByte (in.read ());
+ }
+
+ /**
+ * This method reads 16 unsigned bits into a Java int value from the stream.
+ * It operates by reading two bytes from the stream and converting them to
+ * a single Java <code>int</code> The two bytes are stored most
+ * significant byte first (i.e., "big endian") regardless of the native
+ * host byte ordering.
+ * <p>
+ * As an example, if <code>byte1</code> and <code>byte2</code>
+ * represent the first and second byte read from the stream
+ * respectively, they will be transformed to an <code>int</code> in
+ * the following manner:
+ * <p>
+ * <code>(int)(((byte1 & 0xFF) << 8) + (byte2 & 0xFF))</code>
+ * <p>
+ * The value returned is in the range of 0 to 65535.
+ * <p>
+ * This method can read an unsigned short written by an object
+ * implementing the <code>writeUnsignedShort()</code> method in the
+ * <code>DataOutput</code> interface.
+ *
+ * @return The unsigned short value read as a Java <code>int</code>
+ *
+ * @exception EOFException If end of file is reached before reading the value
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeShort
+ */
+ public final int readUnsignedShort () throws IOException
+ {
+ readFully (buf, 0, 2);
+ return convertToUnsignedShort (buf);
+ }
+
+ /**
+ * This method reads a <code>String</code> from an input stream that
+ * is encoded in a modified UTF-8 format. This format has a leading
+ * two byte sequence that contains the remaining number of bytes to
+ * read. This two byte sequence is read using the
+ * <code>readUnsignedShort()</code> method of this interface.
+ * <p>
+ * After the number of remaining bytes have been determined, these
+ * bytes are read an transformed into <code>char</code> values.
+ * These <code>char</code> values are encoded in the stream using
+ * either a one, two, or three byte format. The particular format
+ * in use can be determined by examining the first byte read.
+ * <p>
+ * If the first byte has a high order bit of 0, then that character
+ * consists on only one byte. This character value consists of
+ * seven bits that are at positions 0 through 6 of the byte. As an
+ * example, if <code>byte1</code> is the byte read from the stream,
+ * it would be converted to a <code>char</code> like so:
+ * <p>
+ * <code>(char)byte1</code>
+ * <p>
+ * If the first byte has 110 as its high order bits, then the
+ * character consists of two bytes. The bits that make up the character
+ * value are in positions 0 through 4 of the first byte and bit positions
+ * 0 through 5 of the second byte. (The second byte should have
+ * 10 as its high order bits). These values are in most significant
+ * byte first (i.e., "big endian") order.
+ * <p>
+ * As an example, if <code>byte1</code> and <code>byte2</code> are
+ * the first two bytes read respectively, and the high order bits of
+ * them match the patterns which indicate a two byte character
+ * encoding, then they would be converted to a Java
+ * <code>char</code> like so:
+ * <p>
+ * <code>(char)(((byte1 & 0x1F) << 6) | (byte2 & 0x3F))</code>
+ * <p>
+ * If the first byte has a 1110 as its high order bits, then the
+ * character consists of three bytes. The bits that make up the character
+ * value are in positions 0 through 3 of the first byte and bit positions
+ * 0 through 5 of the other two bytes. (The second and third bytes should
+ * have 10 as their high order bits). These values are in most
+ * significant byte first (i.e., "big endian") order.
+ * <p>
+ * As an example, if <code>byte1</code> <code>byte2</code> and
+ * <code>byte3</code> are the three bytes read, and the high order
+ * bits of them match the patterns which indicate a three byte
+ * character encoding, then they would be converted to a Java
+ * <code>char</code> like so:
+ * <p>
+ * <code>(char)(((byte1 & 0x0F) << 12) | ((byte2 & 0x3F) << 6) |
+ * (byte3 & 0x3F))</code>
+ * <p>
+ * Note that all characters are encoded in the method that requires
+ * the fewest number of bytes with the exception of the character
+ * with the value of <code>\u0000</code> which is encoded as two
+ * bytes. This is a modification of the UTF standard used to
+ * prevent C language style <code>NUL</code> values from appearing
+ * in the byte stream.
+ * <p>
+ * This method can read data that was written by an object implementing the
+ * <code>writeUTF()</code> method in <code>DataOutput</code>
+ *
+ * @return The <code>String</code> read
+ *
+ * @exception EOFException If end of file is reached before reading
+ * the String
+ * @exception UTFDataFormatException If the data is not in UTF-8 format
+ * @exception IOException If any other error occurs
+ *
+ * @see DataOutput#writeUTF
+ */
+ public final String readUTF () throws IOException
+ {
+ return readUTF (this);
+ }
+
+ /**
+ * This method reads a String encoded in UTF-8 format from the
+ * specified <code>DataInput</code> source.
+ *
+ * @param in The <code>DataInput</code> source to read from
+ *
+ * @return The String read from the source
+ *
+ * @exception IOException If an error occurs
+ *
+ * @see DataInput#readUTF
+ */
+ public static final String readUTF(DataInput in) throws IOException
+ {
+ final int UTFlen = in.readUnsignedShort ();
+ byte[] buf = new byte [UTFlen];
+
+ // 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);
+
+ return convertFromUTF (buf);
+ }
+
+ /**
+ * This method attempts to skip and discard the specified number of bytes
+ * in the input stream. It may actually skip fewer bytes than requested.
+ * This method will not skip any bytes if passed a negative number of bytes
+ * to skip.
+ *
+ * @param n The requested number of bytes to skip.
+ *
+ * @return The requested number of bytes to skip.
+ *
+ * @exception IOException If an error occurs.
+ * @specnote The JDK docs claim that this returns the number of bytes
+ * actually skipped. The JCL claims that this method can throw an
+ * EOFException. Neither of these appear to be true in the JDK 1.3's
+ * implementation. This tries to implement the actual JDK behaviour.
+ */
+ public final int skipBytes (int n) throws IOException
+ {
+ if (n <= 0)
+ return 0;
+ try
+ {
+ return (int) in.skip (n);
+ }
+ catch (EOFException x)
+ {
+ // do nothing.
+ }
+ return n;
+ }
+
+ static boolean convertToBoolean (int b) throws EOFException
+ {
+ if (b < 0)
+ throw new EOFException ();
+
+ return (b != 0);
+ }
+
+ static byte convertToByte (int i) throws EOFException
+ {
+ if (i < 0)
+ throw new EOFException ();
+
+ return (byte) i;
+ }
+
+ static int convertToUnsignedByte (int i) throws EOFException
+ {
+ if (i < 0)
+ throw new EOFException ();
+
+ return (i & 0xFF);
+ }
+
+ static char convertToChar (byte[] buf)
+ {
+ return (char) ((buf [0] << 8)
+ | (buf [1] & 0xff));
+ }
+
+ static short convertToShort (byte[] buf)
+ {
+ return (short) ((buf [0] << 8)
+ | (buf [1] & 0xff));
+ }
+
+ static int convertToUnsignedShort (byte[] buf)
+ {
+ return (((buf [0] & 0xff) << 8)
+ | (buf [1] & 0xff));
+ }
+
+ static int convertToInt (byte[] buf)
+ {
+ return (((buf [0] & 0xff) << 24)
+ | ((buf [1] & 0xff) << 16)
+ | ((buf [2] & 0xff) << 8)
+ | (buf [3] & 0xff));
+ }
+
+ static long convertToLong (byte[] buf)
+ {
+ return (((long)(buf [0] & 0xff) << 56) |
+ ((long)(buf [1] & 0xff) << 48) |
+ ((long)(buf [2] & 0xff) << 40) |
+ ((long)(buf [3] & 0xff) << 32) |
+ ((long)(buf [4] & 0xff) << 24) |
+ ((long)(buf [5] & 0xff) << 16) |
+ ((long)(buf [6] & 0xff) << 8) |
+ ((long)(buf [7] & 0xff)));
+ }
+
+ // FIXME: This method should be re-thought. I suspect we have multiple
+ // UTF-8 decoders floating around. We should use the standard charset
+ // converters, maybe and adding a direct call into one of the new
+ // NIO converters for a super-fast UTF8 decode.
+ static String convertFromUTF (byte[] buf)
+ throws EOFException, UTFDataFormatException
+ {
+ // Give StringBuffer an initial estimated size to avoid
+ // enlarge buffer frequently
+ StringBuffer strbuf = new StringBuffer (buf.length / 2 + 2);
+
+ for (int i = 0; i < buf.length; )
+ {
+ 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 >= buf.length
+ || (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 >= buf.length
+ || (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
+ }
*** Patch too long, truncated ***
More information about the kaffe
mailing list