Menu
▾
▴
[Jnode-svn-commits] SF.net SVN: jnode: [2896] trunk/core/src/classpath/java/java
|
From: <ls...@us...> - 2006-12-12 21:10:02
|
Revision: 2896
http://jnode.svn.sourceforge.net/jnode/?rev=2896&view=rev
Author: lsantha
Date: 2006-12-12 13:09:56 -0800 (Tue, 12 Dec 2006)
Log Message:
-----------
Migrating to Java 5 level classpath.
Added Paths:
-----------
trunk/core/src/classpath/java/java/io/
trunk/core/src/classpath/java/java/io/BufferedInputStream.java
trunk/core/src/classpath/java/java/io/BufferedOutputStream.java
trunk/core/src/classpath/java/java/io/BufferedReader.java
trunk/core/src/classpath/java/java/io/BufferedWriter.java
trunk/core/src/classpath/java/java/io/ByteArrayInputStream.java
trunk/core/src/classpath/java/java/io/ByteArrayOutputStream.java
trunk/core/src/classpath/java/java/io/CharArrayReader.java
trunk/core/src/classpath/java/java/io/CharArrayWriter.java
trunk/core/src/classpath/java/java/io/CharConversionException.java
trunk/core/src/classpath/java/java/io/Closeable.java
trunk/core/src/classpath/java/java/io/DataInput.java
trunk/core/src/classpath/java/java/io/DataInputStream.java
trunk/core/src/classpath/java/java/io/DataOutput.java
trunk/core/src/classpath/java/java/io/DataOutputStream.java
trunk/core/src/classpath/java/java/io/DeleteFileHelper.java
trunk/core/src/classpath/java/java/io/EOFException.java
trunk/core/src/classpath/java/java/io/Externalizable.java
trunk/core/src/classpath/java/java/io/File.java
trunk/core/src/classpath/java/java/io/FileDescriptor.java
trunk/core/src/classpath/java/java/io/FileFilter.java
trunk/core/src/classpath/java/java/io/FileInputStream.java
trunk/core/src/classpath/java/java/io/FileNotFoundException.java
trunk/core/src/classpath/java/java/io/FileOutputStream.java
trunk/core/src/classpath/java/java/io/FilePermission.java
trunk/core/src/classpath/java/java/io/FileReader.java
trunk/core/src/classpath/java/java/io/FileWriter.java
trunk/core/src/classpath/java/java/io/FilenameFilter.java
trunk/core/src/classpath/java/java/io/FilterInputStream.java
trunk/core/src/classpath/java/java/io/FilterOutputStream.java
trunk/core/src/classpath/java/java/io/FilterReader.java
trunk/core/src/classpath/java/java/io/FilterWriter.java
trunk/core/src/classpath/java/java/io/Flushable.java
trunk/core/src/classpath/java/java/io/IOException.java
trunk/core/src/classpath/java/java/io/InputStream.java
trunk/core/src/classpath/java/java/io/InputStreamReader.java
trunk/core/src/classpath/java/java/io/InterruptedIOException.java
trunk/core/src/classpath/java/java/io/InvalidClassException.java
trunk/core/src/classpath/java/java/io/InvalidObjectException.java
trunk/core/src/classpath/java/java/io/LineNumberInputStream.java
trunk/core/src/classpath/java/java/io/LineNumberReader.java
trunk/core/src/classpath/java/java/io/NotActiveException.java
trunk/core/src/classpath/java/java/io/NotSerializableException.java
trunk/core/src/classpath/java/java/io/ObjectInput.java
trunk/core/src/classpath/java/java/io/ObjectInputStream.java
trunk/core/src/classpath/java/java/io/ObjectInputValidation.java
trunk/core/src/classpath/java/java/io/ObjectOutput.java
trunk/core/src/classpath/java/java/io/ObjectOutputStream.java
trunk/core/src/classpath/java/java/io/ObjectStreamClass.java
trunk/core/src/classpath/java/java/io/ObjectStreamConstants.java
trunk/core/src/classpath/java/java/io/ObjectStreamException.java
trunk/core/src/classpath/java/java/io/ObjectStreamField.java
trunk/core/src/classpath/java/java/io/OptionalDataException.java
trunk/core/src/classpath/java/java/io/OutputStream.java
trunk/core/src/classpath/java/java/io/OutputStreamWriter.java
trunk/core/src/classpath/java/java/io/PipedInputStream.java
trunk/core/src/classpath/java/java/io/PipedOutputStream.java
trunk/core/src/classpath/java/java/io/PipedReader.java
trunk/core/src/classpath/java/java/io/PipedWriter.java
trunk/core/src/classpath/java/java/io/PrintStream.java
trunk/core/src/classpath/java/java/io/PrintWriter.java
trunk/core/src/classpath/java/java/io/PushbackInputStream.java
trunk/core/src/classpath/java/java/io/PushbackReader.java
trunk/core/src/classpath/java/java/io/RandomAccessFile.java
trunk/core/src/classpath/java/java/io/Reader.java
trunk/core/src/classpath/java/java/io/SequenceInputStream.java
trunk/core/src/classpath/java/java/io/Serializable.java
trunk/core/src/classpath/java/java/io/SerializablePermission.java
trunk/core/src/classpath/java/java/io/StreamCorruptedException.java
trunk/core/src/classpath/java/java/io/StreamTokenizer.java
trunk/core/src/classpath/java/java/io/StringBufferInputStream.java
trunk/core/src/classpath/java/java/io/StringReader.java
trunk/core/src/classpath/java/java/io/StringWriter.java
trunk/core/src/classpath/java/java/io/SyncFailedException.java
trunk/core/src/classpath/java/java/io/UTFDataFormatException.java
trunk/core/src/classpath/java/java/io/UnsupportedEncodingException.java
trunk/core/src/classpath/java/java/io/WriteAbortedException.java
trunk/core/src/classpath/java/java/io/Writer.java
trunk/core/src/classpath/java/java/io/class-dependencies.conf
trunk/core/src/classpath/java/java/io/package.html
Added: trunk/core/src/classpath/java/java/io/BufferedInputStream.java
===================================================================
--- trunk/core/src/classpath/java/java/io/BufferedInputStream.java (rev 0)
+++ trunk/core/src/classpath/java/java/io/BufferedInputStream.java 2006-12-12 21:09:56 UTC (rev 2896)
@@ -0,0 +1,379 @@
+/* BufferedInputStream.java -- An input stream that implements buffering
+ Copyright (C) 1998, 1999, 2001, 2005 Free Software Foundation, Inc.
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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>FilterInputStream</code> buffers input from an
+ * underlying implementation to provide a possibly more efficient read
+ * mechanism. It maintains the buffer and buffer state in instance
+ * variables that are available to subclasses. The default buffer size
+ * of 2048 bytes can be overridden by the creator of the stream.
+ * <p>
+ * This class also implements mark/reset functionality. It is capable
+ * of remembering any number of input bytes, to the limits of
+ * system memory or the size of <code>Integer.MAX_VALUE</code>
+ * <p>
+ * Please note that this class does not properly handle character
+ * encodings. Consider using the <code>BufferedReader</code> class which
+ * does.
+ *
+ * @author Aaron M. Renn (ar...@ur...)
+ * @author Warren Levy (wa...@cy...)
+ * @author Jeroen Frijters (je...@fr...)
+ */
+public class BufferedInputStream extends FilterInputStream
+{
+
+ /**
+ * This is the default buffer size
+ */
+ private static final int DEFAULT_BUFFER_SIZE = 2048;
+
+ /**
+ * The buffer used for storing data from the underlying stream.
+ */
+ protected byte[] buf;
+
+ /**
+ * The number of valid bytes currently in the buffer. It is also the index
+ * of the buffer position one byte past the end of the valid data.
+ */
+ protected int count;
+
+ /**
+ * The index of the next character that will by read from the buffer.
+ * When <code>pos == count</code>, the buffer is empty.
+ */
+ protected int pos;
+
+ /**
+ * The value of <code>pos</code> when the <code>mark()</code> method was
+ * called.
+ * This is set to -1 if there is no mark set.
+ */
+ protected int markpos = -1;
+
+ /**
+ * This is the maximum number of bytes than can be read after a
+ * call to <code>mark()</code> before the mark can be discarded.
+ * After this may bytes are read, the <code>reset()</code> method
+ * may not be called successfully.
+ */
+ protected int marklimit;
+
+ /**
+ * This is the initial buffer size. When the buffer is grown because
+ * of marking requirements, it will be grown by bufferSize increments.
+ * The underlying stream will be read in chunks of bufferSize.
+ */
+ private final int bufferSize;
+
+ /**
+ * This method initializes a new <code>BufferedInputStream</code> that will
+ * read from the specified subordinate stream with a default buffer size
+ * of 2048 bytes
+ *
+ * @param in The subordinate stream to read from
+ */
+ public BufferedInputStream(InputStream in)
+ {
+ this(in, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * This method initializes a new <code>BufferedInputStream</code> that will
+ * read from the specified subordinate stream with a buffer size that
+ * is specified by the caller.
+ *
+ * @param in The subordinate stream to read from
+ * @param size The buffer size to use
+ *
+ * @exception IllegalArgumentException when size is smaller then 1
+ */
+ public BufferedInputStream(InputStream in, int size)
+ {
+ super(in);
+ if (size <= 0)
+ throw new IllegalArgumentException();
+ buf = new byte[size];
+ // initialize pos & count to bufferSize, to prevent refill from
+ // allocating a new buffer (if the caller starts out by calling mark()).
+ pos = count = bufferSize = size;
+ }
+
+ /**
+ * This method returns the number of bytes that can be read from this
+ * stream before a read can block. A return of 0 indicates that blocking
+ * might (or might not) occur on the very next read attempt.
+ * <p>
+ * The number of available bytes will be the number of read ahead bytes
+ * stored in the internal buffer plus the number of available bytes in
+ * the underlying stream.
+ *
+ * @return The number of bytes that can be read before blocking could occur
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized int available() throws IOException
+ {
+ return count - pos + super.available();
+ }
+
+ /**
+ * This method closes the underlying input stream and frees any
+ * resources associated with it. Sets <code>buf</code> to <code>null</code>.
+ *
+ * @exception IOException If an error occurs.
+ */
+ public void close() throws IOException
+ {
+ // Free up the array memory.
+ buf = null;
+ pos = count = 0;
+ markpos = -1;
+ super.close();
+ }
+
+ /**
+ * This method marks a position in the input to which the stream can be
+ * "reset" by calling the <code>reset()</code> method. The parameter
+ * <code>readlimit</code> is the number of bytes that can be read from the
+ * stream after setting the mark before the mark becomes invalid. For
+ * example, if <code>mark()</code> is called with a read limit of 10, then
+ * when 11 bytes of data are read from the stream before the
+ * <code>reset()</code> method is called, then the mark is invalid and the
+ * stream object instance is not required to remember the mark.
+ * <p>
+ * Note that the number of bytes that can be remembered by this method
+ * can be greater than the size of the internal read buffer. It is also
+ * not dependent on the subordinate stream supporting mark/reset
+ * functionality.
+ *
+ * @param readlimit The number of bytes that can be read before the mark
+ * becomes invalid
+ */
+ public synchronized void mark(int readlimit)
+ {
+ marklimit = readlimit;
+ markpos = pos;
+ }
+
+ /**
+ * This method returns <code>true</code> to indicate that this class
+ * supports mark/reset functionality.
+ *
+ * @return <code>true</code> to indicate that mark/reset functionality is
+ * supported
+ *
+ */
+ public boolean markSupported()
+ {
+ return true;
+ }
+
+ /**
+ * This method reads an unsigned byte from the input stream and returns it
+ * as an int in the range of 0-255. This method also will return -1 if
+ * the end of the stream has been reached.
+ * <p>
+ * This method will block until the byte can be read.
+ *
+ * @return The byte read or -1 if end of stream
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized int read() throws IOException
+ {
+ if (pos >= count && !refill())
+ return -1; // EOF
+
+ return buf[pos++] & 0xFF;
+ }
+
+ /**
+ * This method reads bytes from a stream and stores them into a caller
+ * supplied buffer. It starts storing the data at index <code>off</code>
+ * into the buffer and attempts to read <code>len</code> bytes. This method
+ * can return before reading the number of bytes requested, but it will try
+ * to read the requested number of bytes by repeatedly calling the underlying
+ * stream as long as available() for this stream continues to return a
+ * non-zero value (or until the requested number of bytes have been read).
+ * The actual number of bytes read is returned as an int. A -1 is returned
+ * to indicate the end of the stream.
+ * <p>
+ * This method will block until some data can be read.
+ *
+ * @param b The array into which the bytes read should be stored
+ * @param off The offset into the array 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.
+ *
+ * @exception IOException If an error occurs.
+ * @exception IndexOutOfBoundsException when <code>off</code> or
+ * <code>len</code> are negative, or when <code>off + len</code>
+ * is larger then the size of <code>b</code>,
+ */
+ public synchronized int read(byte[] b, int off, int len) throws IOException
+ {
+ if (off < 0 || len < 0 || b.length - off < len)
+ throw new IndexOutOfBoundsException();
+
+ if (len == 0)
+ return 0;
+
+ if (pos >= count && !refill())
+ return -1; // No bytes were read before EOF.
+
+ int totalBytesRead = Math.min(count - pos, len);
+ System.arraycopy(buf, pos, b, off, totalBytesRead);
+ pos += totalBytesRead;
+ off += totalBytesRead;
+ len -= totalBytesRead;
+
+ while (len > 0 && super.available() > 0 && refill())
+ {
+ int remain = Math.min(count - pos, len);
+ System.arraycopy(buf, pos, b, off, remain);
+ pos += remain;
+ off += remain;
+ len -= remain;
+ totalBytesRead += remain;
+ }
+
+ return totalBytesRead;
+ }
+
+ /**
+ * This method resets a stream to the point where the <code>mark()</code>
+ * method was called. Any bytes that were read after the mark point was
+ * set will be re-read during subsequent reads.
+ * <p>
+ * This method will throw an IOException if the number of bytes read from
+ * the stream since the call to <code>mark()</code> exceeds the mark limit
+ * passed when establishing the mark.
+ *
+ * @exception IOException If <code>mark()</code> was never called or more
+ * then <code>marklimit</code> bytes were read since the last
+ * call to <code>mark()</code>
+ */
+ public synchronized void reset() throws IOException
+ {
+ if (markpos == -1)
+ throw new IOException(buf == null ? "Stream closed." : "Invalid mark.");
+
+ pos = markpos;
+ }
+
+ /**
+ * This method skips the specified number of bytes in the stream. It
+ * returns the actual number of bytes skipped, which may be less than the
+ * requested amount.
+ *
+ * @param n The requested number of bytes to skip
+ *
+ * @return The actual number of bytes skipped.
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized long skip(long n) throws IOException
+ {
+ if (buf == null)
+ throw new IOException("Stream closed.");
+
+ final long origN = n;
+
+ while (n > 0L)
+ {
+ if (pos >= count && !refill())
+ break;
+
+ int numread = (int) Math.min((long) (count - pos), n);
+ pos += numread;
+ n -= numread;
+ }
+
+ return origN - n;
+ }
+
+ /**
+ * Called to refill the buffer (when count is equal to pos).
+ *
+ * @return <code>true</code> when at least one additional byte was read
+ * into <code>buf</code>, <code>false</code> otherwise (at EOF).
+ */
+ private boolean refill() throws IOException
+ {
+ if (buf == null)
+ throw new IOException("Stream closed.");
+
+ if (markpos == -1 || count - markpos >= marklimit)
+ {
+ markpos = -1;
+ pos = count = 0;
+ }
+ else
+ {
+ byte[] newbuf = buf;
+ if (markpos < bufferSize)
+ {
+ newbuf = new byte[count - markpos + bufferSize];
+ }
+ System.arraycopy(buf, markpos, newbuf, 0, count - markpos);
+ buf = newbuf;
+ count -= markpos;
+ pos -= markpos;
+ markpos = 0;
+ }
+
+ int numread = super.read(buf, count, bufferSize);
+
+ if (numread <= 0) // EOF
+ return false;
+
+ count += numread;
+ return true;
+ }
+}
Added: trunk/core/src/classpath/java/java/io/BufferedOutputStream.java
===================================================================
--- trunk/core/src/classpath/java/java/io/BufferedOutputStream.java (rev 0)
+++ trunk/core/src/classpath/java/java/io/BufferedOutputStream.java 2006-12-12 21:09:56 UTC (rev 2896)
@@ -0,0 +1,192 @@
+/* BufferedOutputStream.java -- Buffer output into large blocks before writing
+ Copyright (C) 1998, 2000, 2003 Free Software Foundation, Inc.
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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;
+
+/**
+ * This class accumulates bytes written in a buffer instead of immediately
+ * writing the data to the underlying output sink. The bytes are instead
+ * as one large block when the buffer is filled, or when the stream is
+ * closed or explicitly flushed. This mode operation can provide a more
+ * efficient mechanism for writing versus doing numerous small unbuffered
+ * writes.
+ *
+ * @author Aaron M. Renn (ar...@ur...)
+ */
+public class BufferedOutputStream extends FilterOutputStream
+{
+ /**
+ * This is the default buffer size
+ */
+ private static final int DEFAULT_BUFFER_SIZE = 512;
+
+ /**
+ * This is the internal byte array used for buffering output before
+ * writing it.
+ */
+ protected byte[] buf;
+
+ /**
+ * This is the number of bytes that are currently in the buffer and
+ * are waiting to be written to the underlying stream. It always points to
+ * the index into the buffer where the next byte of data will be stored
+ */
+ protected int count;
+
+ /**
+ * This method initializes a new <code>BufferedOutputStream</code> instance
+ * that will write to the specified subordinate <code>OutputStream</code>
+ * and which will use a default buffer size of 512 bytes.
+ *
+ * @param out The underlying <code>OutputStream</code> to write data to
+ */
+ public BufferedOutputStream(OutputStream out)
+ {
+ this(out, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * This method initializes a new <code>BufferedOutputStream</code> instance
+ * that will write to the specified subordinate <code>OutputStream</code>
+ * and which will use the specified buffer size
+ *
+ * @param out The underlying <code>OutputStream</code> to write data to
+ * @param size The size of the internal buffer
+ */
+ public BufferedOutputStream(OutputStream out, int size)
+ {
+ super(out);
+
+ buf = new byte[size];
+ }
+
+ /**
+ * This method causes any currently buffered bytes to be immediately
+ * written to the underlying output stream.
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized void flush() throws IOException
+ {
+ if (count == 0)
+ return;
+
+ out.write(buf, 0, count);
+ count = 0;
+ out.flush();
+ }
+
+ /**
+ * This method flushes any remaining buffered bytes then closes the
+ * underlying output stream. Any further attempts to write to this stream
+ * may throw an exception
+ *
+ public synchronized void close() throws IOException
+ {
+ flush();
+ out.close();
+ }
+ */
+
+ /**
+ * This method runs when the object is garbage collected. It is
+ * responsible for ensuring that all buffered bytes are written and
+ * for closing the underlying stream.
+ *
+ * @exception IOException If an error occurs (ignored by the Java runtime)
+ *
+ protected void finalize() throws IOException
+ {
+ close();
+ }
+ */
+
+ /**
+ * This method writes a single byte of data. This will be written to the
+ * buffer instead of the underlying data source. However, if the buffer
+ * is filled as a result of this write request, it will be flushed to the
+ * underlying output stream.
+ *
+ * @param b The byte of data to be written, passed as an int
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized void write(int b) throws IOException
+ {
+ if (count == buf.length)
+ flush();
+
+ buf[count] = (byte)(b & 0xFF);
+ ++count;
+ }
+
+ /**
+ * This method writes <code>len</code> bytes from the byte array
+ * <code>buf</code> starting at position <code>offset</code> in the buffer.
+ * These bytes will be written to the internal buffer. However, if this
+ * write operation fills the buffer, the buffer will be flushed to the
+ * underlying output stream.
+ *
+ * @param buf The array of bytes to write.
+ * @param offset The index into the byte array to start writing from.
+ * @param len The number of bytes to write.
+ *
+ * @exception IOException If an error occurs
+ */
+ public synchronized void write(byte[] buf, int offset, int len)
+ throws IOException
+ {
+ // Buffer can hold everything. Note that the case where LEN < 0
+ // is automatically handled by the downstream write.
+ if (len < (this.buf.length - count))
+ {
+ System.arraycopy(buf, offset, this.buf, count, len);
+ count += len;
+ }
+ else
+ {
+ // The write was too big. So flush the buffer and write the new
+ // bytes directly to the underlying stream, per the JDK 1.2
+ // docs.
+ flush();
+ out.write (buf, offset, len);
+ }
+ }
+
+} // class BufferedOutputStream
+
Added: trunk/core/src/classpath/java/java/io/BufferedReader.java
===================================================================
--- trunk/core/src/classpath/java/java/io/BufferedReader.java (rev 0)
+++ trunk/core/src/classpath/java/java/io/BufferedReader.java 2006-12-12 21:09:56 UTC (rev 2896)
@@ -0,0 +1,581 @@
+/* BufferedReader.java
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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, plus online
+ * API docs for JDK 1.2 beta from http://www.javasoft.com.
+ * Status: Believed complete and correct.
+ */
+
+/**
+ * This subclass of <code>FilterReader</code> buffers input from an
+ * underlying implementation to provide a possibly more efficient read
+ * mechanism. It maintains the buffer and buffer state in instance
+ * variables that are available to subclasses. The default buffer size
+ * of 8192 chars can be overridden by the creator of the stream.
+ * <p>
+ * This class also implements mark/reset functionality. It is capable
+ * of remembering any number of input chars, to the limits of
+ * system memory or the size of <code>Integer.MAX_VALUE</code>
+ *
+ * @author Per Bothner (bo...@cy...)
+ * @author Aaron M. Renn (ar...@ur...)
+ */
+public class BufferedReader extends Reader
+{
+ Reader in;
+ char[] buffer;
+ /* Index of current read position. Must be >= 0 and <= limit. */
+ /* There is a special case where pos may be equal to limit+1; this
+ * is used as an indicator that a readLine was done with a '\r' was
+ * the very last char in the buffer. Since we don't want to read-ahead
+ * and potentially block, we set pos this way to indicate the situation
+ * and deal with it later. Doing it this way rather than having a
+ * separate boolean field to indicate the condition has the advantage
+ * that it is self-clearing on things like mark/reset.
+ */
+ int pos;
+ /* Limit of valid data in buffer. Must be >= pos and <= buffer.length. */
+ /* This can be < pos in the one special case described above. */
+ int limit;
+
+ /* The value -1 means there is no mark, or the mark has been invalidated.
+ Otherwise, markPos is the index in the buffer of the marked position.
+ Must be >= 0 and <= pos.
+ Note we do not explicitly store the read-limit.
+ The implicit read-limit is (buffer.length - markPos), which is
+ guaranteed to be >= the read-limit requested in the call to mark. */
+ int markPos = -1;
+
+ // The JCL book specifies the default buffer size as 8K characters.
+ // This is package-private because it is used by LineNumberReader.
+ static final int DEFAULT_BUFFER_SIZE = 8192;
+
+ /**
+ * The line buffer for <code>readLine</code>.
+ */
+ private StringBuffer sbuf = null;
+
+ /**
+ * Create a new <code>BufferedReader</code> that will read from the
+ * specified subordinate stream with a default buffer size of 8192 chars.
+ *
+ * @param in The subordinate stream to read from
+ */
+ public BufferedReader(Reader in)
+ {
+ this(in, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * Create a new <code>BufferedReader</code> that will read from the
+ * specified subordinate stream with a buffer size that is specified by the
+ * caller.
+ *
+ * @param in The subordinate stream to read from
+ * @param size The buffer size to use
+ *
+ * @exception IllegalArgumentException if size <= 0
+ */
+ public BufferedReader(Reader in, int size)
+ {
+ super(in.lock);
+ if (size <= 0)
+ throw new IllegalArgumentException("Illegal buffer size: " + size);
+ this.in = in;
+ buffer = new char[size];
+ }
+
+ /**
+ * This method closes the underlying stream and frees any associated
+ * resources.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void close() throws IOException
+ {
+ synchronized (lock)
+ {
+ if (in != null)
+ in.close();
+ in = null;
+ buffer = null;
+ }
+ }
+
+ /**
+ * Returns <code>true</code> to indicate that this class supports mark/reset
+ * functionality.
+ *
+ * @return <code>true</code>
+ */
+ public boolean markSupported()
+ {
+ return true;
+ }
+
+ /**
+ * Mark a position in the input to which the stream can be
+ * "reset" by calling the <code>reset()</code> method. The parameter
+ * <code>readLimit</code> is the number of chars that can be read from the
+ * stream after setting the mark before the mark becomes invalid. For
+ * example, if <code>mark()</code> is called with a read limit of 10, then
+ * when 11 chars of data are read from the stream before the
+ * <code>reset()</code> method is called, then the mark is invalid and the
+ * stream object instance is not required to remember the mark.
+ * <p>
+ * Note that the number of chars that can be remembered by this method
+ * can be greater than the size of the internal read buffer. It is also
+ * not dependent on the subordinate stream supporting mark/reset
+ * functionality.
+ *
+ * @param readLimit The number of chars that can be read before the mark
+ * becomes invalid
+ *
+ * @exception IOException If an error occurs
+ * @exception IllegalArgumentException if readLimit is negative.
+ */
+ public void mark(int readLimit) throws IOException
+ {
+ if (readLimit < 0)
+ throw new IllegalArgumentException("Read-ahead limit is negative");
+
+ synchronized (lock)
+ {
+ checkStatus();
+ // In this method we need to be aware of the special case where
+ // pos + 1 == limit. This indicates that a '\r' was the last char
+ // in the buffer during a readLine. We'll want to maintain that
+ // condition after we shift things around and if a larger buffer is
+ // needed to track readLimit, we'll have to make it one element
+ // larger to ensure we don't invalidate the mark too early, if the
+ // char following the '\r' is NOT a '\n'. This is ok because, per
+ // the spec, we are not required to invalidate when passing readLimit.
+ //
+ // Note that if 'pos > limit', then doing 'limit -= pos' will cause
+ // limit to be negative. This is the only way limit will be < 0.
+
+ if (pos + readLimit > limit)
+ {
+ char[] old_buffer = buffer;
+ int extraBuffSpace = 0;
+ if (pos > limit)
+ extraBuffSpace = 1;
+ if (readLimit + extraBuffSpace > limit)
+ buffer = new char[readLimit + extraBuffSpace];
+ limit -= pos;
+ if (limit >= 0)
+ {
+ System.arraycopy(old_buffer, pos, buffer, 0, limit);
+ pos = 0;
+ }
+ }
+
+ if (limit < 0)
+ {
+ // Maintain the relationship of 'pos > limit'.
+ pos = 1;
+ limit = markPos = 0;
+ }
+ else
+ markPos = pos;
+ // Now pos + readLimit <= buffer.length. thus if we need to read
+ // beyond buffer.length, then we are allowed to invalidate markPos.
+ }
+ }
+
+ /**
+ * Reset the stream to the point where the <code>mark()</code> method
+ * was called. Any chars that were read after the mark point was set will
+ * be re-read during subsequent reads.
+ * <p>
+ * This method will throw an IOException if the number of chars read from
+ * the stream since the call to <code>mark()</code> exceeds the mark limit
+ * passed when establishing the mark.
+ *
+ * @exception IOException If an error occurs;
+ */
+ public void reset() throws IOException
+ {
+ synchronized (lock)
+ {
+ checkStatus();
+ if (markPos < 0)
+ throw new IOException("mark never set or invalidated");
+
+ // Need to handle the extremely unlikely case where a readLine was
+ // done with a '\r' as the last char in the buffer; which was then
+ // immediately followed by a mark and a reset with NO intervening
+ // read of any sort. In that case, setting pos to markPos would
+ // lose that info and a subsequent read would thus not skip a '\n'
+ // (if one exists). The value of limit in this rare case is zero.
+ // We can assume that if limit is zero for other reasons, then
+ // pos is already set to zero and doesn't need to be readjusted.
+ if (limit > 0)
+ pos = markPos;
+ }
+ }
+
+ /**
+ * This method determines whether or not a stream is ready to be read. If
+ * this method returns <code>false</code> then this stream could (but is
+ * not guaranteed to) block on the next read attempt.
+ *
+ * @return <code>true</code> if this stream is ready to be read,
+ * <code>false</code> otherwise
+ *
+ * @exception IOException If an error occurs
+ */
+ public boolean ready() throws IOException
+ {
+ synchronized (lock)
+ {
+ checkStatus();
+ return pos < limit || in.ready();
+ }
+ }
+
+ /**
+ * This method read chars from a stream and stores them into a caller
+ * supplied buffer. It starts storing the data at index
+ * <code>offset</code> into
+ * the buffer and attempts to read <code>len</code> chars. This method can
+ * return before reading the number of chars requested. The actual number
+ * of chars read is returned as an int. A -1 is returned to indicate the
+ * end of the stream.
+ * <p>
+ * This method will block until some data can be read.
+ *
+ * @param buf The array into which the chars read should be stored
+ * @param offset The offset into the array to start storing chars
+ * @param count The requested number of chars to read
+ *
+ * @return The actual number of chars read, or -1 if end of stream.
+ *
+ * @exception IOException If an error occurs.
+ * @exception IndexOutOfBoundsException If offset and count are not
+ * valid regarding buf.
+ */
+ public int read(char[] buf, int offset, int count) throws IOException
+ {
+ if (offset < 0 || offset + count > buf.length || count < 0)
+ throw new IndexOutOfBoundsException();
+
+ synchronized (lock)
+ {
+ checkStatus();
+ // Once again, we need to handle the special case of a readLine
+ // that has a '\r' at the end of the buffer. In this case, we'll
+ // need to skip a '\n' if it is the next char to be read.
+ // This special case is indicated by 'pos > limit'.
+ boolean retAtEndOfBuffer = false;
+
+ int avail = limit - pos;
+ if (count > avail)
+ {
+ if (avail > 0)
+ count = avail;
+ else // pos >= limit
+ {
+ if (limit == buffer.length)
+ markPos = -1; // read too far - invalidate the mark.
+ if (pos > limit)
+ {
+ // Set a boolean and make pos == limit to simplify things.
+ retAtEndOfBuffer = true;
+ --pos;
+ }
+ if (markPos < 0)
+ {
+ // Optimization: can read directly into buf.
+ if (count >= buffer.length && !retAtEndOfBuffer)
+ return in.read(buf, offset, count);
+ pos = limit = 0;
+ }
+ avail = in.read(buffer, limit, buffer.length - limit);
+ if (retAtEndOfBuffer && avail > 0 && buffer[limit] == '\n')
+ {
+ --avail;
+ limit++;
+ }
+ if (avail < count)
+ {
+ if (avail <= 0)
+ return avail;
+ count = avail;
+ }
+ limit += avail;
+ }
+ }
+ System.arraycopy(buffer, pos, buf, offset, count);
+ pos += count;
+ return count;
+ }
+ }
+
+ /* Read more data into the buffer. Update pos and limit appropriately.
+ Assumes pos==limit initially. May invalidate the mark if read too much.
+ Return number of chars read (never 0), or -1 on eof. */
+ private int fill() throws IOException
+ {
+ checkStatus();
+ // Handle the special case of a readLine that has a '\r' at the end of
+ // the buffer. In this case, we'll need to skip a '\n' if it is the
+ // next char to be read. This special case is indicated by 'pos > limit'.
+ boolean retAtEndOfBuffer = false;
+ if (pos > limit)
+ {
+ retAtEndOfBuffer = true;
+ --pos;
+ }
+
+ if (markPos >= 0 && limit == buffer.length)
+ markPos = -1;
+ if (markPos < 0)
+ pos = limit = 0;
+ int count = in.read(buffer, limit, buffer.length - limit);
+ if (count > 0)
+ limit += count;
+
+ if (retAtEndOfBuffer && buffer[pos] == '\n')
+ {
+ --count;
+ // If the mark was set to the location of the \n, then we
+ // must change it to fully pretend that the \n does not
+ // exist.
+ if (markPos == pos)
+ ++markPos;
+ ++pos;
+ }
+
+ return count;
+ }
+
+ public int read() throws IOException
+ {
+ synchronized (lock)
+ {
+ checkStatus();
+ if (pos >= limit && fill () <= 0)
+ return -1;
+ return buffer[pos++];
+ }
+ }
+
+ /* Return the end of the line starting at this.pos and ending at limit.
+ * The index returns is *before* any line terminators, or limit
+ * if no line terminators were found.
+ */
+ private int lineEnd(int limit)
+ {
+ int i = pos;
+ for (; i < limit; i++)
+ {
+ char ch = buffer[i];
+ if (ch == '\n' || ch == '\r')
+ break;
+ }
+ return i;
+ }
+
+ /**
+ * This method reads a single line of text from the input stream, returning
+ * it as a <code>String</code>. A line is terminated by "\n", a "\r", or
+ * an "\r\n" sequence. The system dependent line separator is not used.
+ * The line termination characters are not returned in the resulting
+ * <code>String</code>.
+ *
+ * @return The line of text read, or <code>null</code> if end of stream.
+ *
+ * @exception IOException If an error occurs
+ */
+ public String readLine() throws IOException
+ {
+ checkStatus();
+ // Handle the special case where a previous readLine (with no intervening
+ // reads/skips) had a '\r' at the end of the buffer.
+ // In this case, we'll need to skip a '\n' if it's the next char to be read.
+ // This special case is indicated by 'pos > limit'.
+ if (pos > limit)
+ {
+ int ch = read();
+ if (ch < 0)
+ return null;
+ if (ch != '\n')
+ --pos;
+ }
+ int i = lineEnd(limit);
+ if (i < limit)
+ {
+ String str = String.valueOf(buffer, pos, i - pos);
+ pos = i + 1;
+ // If the last char in the buffer is a '\r', we must remember
+ // to check if the next char to be read after the buffer is refilled
+ // is a '\n'. If so, skip it. To indicate this condition, we set pos
+ // to be limit + 1, which normally is never possible.
+ if (buffer[i] == '\r')
+ if (pos == limit || buffer[pos] == '\n')
+ pos++;
+ return str;
+ }
+ if (sbuf == null)
+ sbuf = new StringBuffer(200);
+ else
+ sbuf.setLength(0);
+ sbuf.append(buffer, pos, i - pos);
+ pos = i;
+ // We only want to return null when no characters were read before
+ // EOF. So we must keep track of this separately. Otherwise we
+ // would treat an empty `sbuf' as an EOF condition, which is wrong
+ // when there is just a newline.
+ boolean eof = false;
+ for (;;)
+ {
+ // readLine should block. So we must not return until a -1 is reached.
+ if (pos >= limit)
+ {
+ // here count == 0 isn't sufficient to give a failure.
+ int count = fill();
+ if (count < 0)
+ {
+ eof = true;
+ break;
+ }
+ continue;
+ }
+ int ch = buffer[pos++];
+ if (ch == '\n' || ch == '\r')
+ {
+ // Check here if a '\r' was the last char in the buffer; if so,
+ // mark it as in the comment above to indicate future reads
+ // should skip a newline that is the next char read after
+ // refilling the buffer.
+ if (ch == '\r')
+ if (pos == limit || buffer[pos] == '\n')
+ pos++;
+ break;
+ }
+ i = lineEnd(limit);
+ sbuf.append(buffer, pos - 1, i - (pos - 1));
+ pos = i;
+ }
+ return (sbuf.length() == 0 && eof) ? null : sbuf.toString();
+ }
+
+ /**
+ * This method skips the specified number of chars in the stream. It
+ * returns the actual number of chars skipped, which may be less than the
+ * requested amount.
+ * <p>
+ * This method first discards chars in the buffer, then calls the
+ * <code>skip</code> method on the underlying stream to skip the
+ * remaining chars.
+ *
+ * @param count The requested number of chars to skip
+ *
+ * @return The actual number of chars skipped.
+ *
+ * @exception IOException If an error occurs.
+ * @exception IllegalArgumentException If count is negative.
+ */
+ public long skip(long count) throws IOException
+ {
+ synchronized (lock)
+ {
+ checkStatus();
+ if (count < 0)
+ throw new IllegalArgumentException("skip value is negative");
+ if (count == 0)
+ return 0;
+ // Yet again, we need to handle the special case of a readLine
+ // that has a '\r' at the end of the buffer. In this case, we need
+ // to ignore a '\n' if it is the next char to be read.
+ // This special case is indicated by 'pos > limit' (i.e. avail < 0).
+ // To simplify things, if we're dealing with the special case for
+ // readLine, just read the next char (since the fill method will
+ // skip the '\n' for us). By doing this, we'll have to back up pos.
+ // That's easier than trying to keep track of whether we've skipped
+ // one element or not.
+ if (pos > limit)
+ {
+ if (read() < 0)
+ return 0;
+ else
+ --pos;
+ }
+
+ int avail = limit - pos;
+
+ if (count < avail)
+ {
+ pos += count;
+ return count;
+ }
+
+ pos = limit;
+ long todo = count - avail;
+ if (todo > buffer.length)
+ {
+ markPos = -1;
+ todo -= in.skip(todo);
+ }
+ else
+ {
+ while (todo > 0)
+ {
+ avail = fill();
+ if (avail <= 0)
+ break;
+ if (avail > todo)
+ avail = (int) todo;
+ pos += avail;
+ todo -= avail;
+ }
+ }
+ return count - todo;
+ }
+ }
+
+ private void checkStatus() throws IOException
+ {
+ if (in == null)
+ throw new IOException("Stream closed");
+ }
+}
Added: trunk/core/src/classpath/java/java/io/BufferedWriter.java
===================================================================
--- trunk/core/src/classpath/java/java/io/BufferedWriter.java (rev 0)
+++ trunk/core/src/classpath/java/java/io/BufferedWriter.java 2006-12-12 21:09:56 UTC (rev 2896)
@@ -0,0 +1,262 @@
+/* BufferedWriter.java -- Buffer output into large blocks before writing
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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
+ * Status: Complete to version 1.1.
+ */
+
+/**
+ * This class accumulates chars written in a buffer instead of immediately
+ * writing the data to the underlying output sink. The chars are instead
+ * as one large block when the buffer is filled, or when the stream is
+ * closed or explicitly flushed. This mode operation can provide a more
+ * efficient mechanism for writing versus doing numerous small unbuffered
+ * writes.
+ *
+ * @author Aaron M. Renn (ar...@ur...)
+ * @author Tom Tromey (tr...@cy...)
+ * @date September 25, 1998
+ */
+public class BufferedWriter extends Writer
+{
+ /**
+ * This is the default buffer size
+ */
+ private static final int DEFAULT_BUFFER_SIZE = 8192;
+
+ /**
+ * This is the underlying <code>Writer</code> to which this object
+ * sends its output.
+ */
+ private Writer out;
+
+ /**
+ * This is the internal char array used for buffering output before
+ * writing it.
+ */
+ char[] buffer;
+
+ /**
+ * This is the number of chars that are currently in the buffer and
+ * are waiting to be written to the underlying stream. It always points to
+ * the index into the buffer where the next char of data will be stored
+ */
+ int count;
+
+ /**
+ * This method initializes a new <code>BufferedWriter</code> instance
+ * that will write to the specified subordinate <code>Writer</code>
+ * and which will use a default buffer size of 8192 chars.
+ *
+ * @param out The underlying <code>Writer</code> to write data to
+ */
+ public BufferedWriter (Writer out)
+ {
+ this (out, DEFAULT_BUFFER_SIZE);
+ }
+
+ /**
+ * This method initializes a new <code>BufferedWriter</code> instance
+ * that will write to the specified subordinate <code>Writer</code>
+ * and which will use the specified buffer size
+ *
+ * @param out The underlying <code>Writer</code> to write data to
+ * @param size The size of the internal buffer
+ */
+ public BufferedWriter (Writer out, int size)
+ {
+ super(out.lock);
+ this.out = out;
+ this.buffer = new char[size];
+ this.count = 0;
+ }
+
+ /**
+ * This method flushes any remaining buffered chars then closes the
+ * underlying output stream. Any further attempts to write to this stream
+ * may throw an exception
+ *
+ * @exception IOException If an error occurs.
+ */
+ public void close () throws IOException
+ {
+ synchronized (lock)
+ {
+ // It is safe to call localFlush even if the stream is already
+ // closed.
+ localFlush ();
+ out.close();
+ buffer = null;
+ }
+ }
+
+ /**
+ * This method causes any currently buffered chars to be immediately
+ * written to the underlying output stream.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void flush () throws IOException
+ {
+ synchronized (lock)
+ {
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+ localFlush ();
+ out.flush();
+ }
+ }
+
+ /**
+ * This method writes out a system depedent line separator sequence. The
+ * actual value written is detemined from the <xmp>line.separator</xmp>
+ * system property.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void newLine () throws IOException
+ {
+ write (System.getProperty("line.separator"));
+ }
+
+ /**
+ * This method writes a single char of data. This will be written to the
+ * buffer instead of the underlying data source. However, if the buffer
+ * is filled as a result of this write request, it will be flushed to the
+ * underlying output stream.
+ *
+ * @param oneChar The char of data to be written, passed as an int
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write (int oneChar) throws IOException
+ {
+ synchronized (lock)
+ {
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+ buffer[count++] = (char) oneChar;
+ if (count == buffer.length)
+ localFlush ();
+ }
+ }
+
+ /**
+ * This method writes <code>len</code> chars from the char array
+ * <code>buf</code> starting at position <code>offset</code> in the buffer.
+ * These chars will be written to the internal buffer. However, if this
+ * write operation fills the buffer, the buffer will be flushed to the
+ * underlying output stream.
+ *
+ * @param buf The array of chars to write.
+ * @param offset The index into the char array to start writing from.
+ * @param len The number of chars to write.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write (char[] buf, int offset, int len) throws IOException
+ {
+ synchronized (lock)
+ {
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+
+ // Bypass buffering if there is too much incoming data.
+ if (count + len > buffer.length)
+ {
+ localFlush ();
+ out.write(buf, offset, len);
+ }
+ else
+ {
+ System.arraycopy(buf, offset, buffer, count, len);
+ count += len;
+ if (count == buffer.length)
+ localFlush ();
+ }
+ }
+ }
+
+ /**
+ * This method writes <code>len</code> chars from the <code>String</code>
+ * <code>str</code> starting at position <code>offset</code> in the string.
+ * These chars will be written to the internal buffer. However, if this
+ * write operation fills the buffer, the buffer will be flushed to the
+ * underlying output stream.
+ *
+ * @param str The <code>String</code> to write.
+ * @param offset The index into the string to start writing from.
+ * @param len The number of chars to write.
+ *
+ * @exception IOException If an error occurs
+ */
+ public void write (String str, int offset, int len) throws IOException
+ {
+ synchronized (lock)
+ {
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+
+ if (count + len > buffer.length)
+ {
+ localFlush ();
+ out.write(str, offset, len);
+ }
+ else
+ {
+ str.getChars(offset, offset + len, buffer, count);
+ count += len;
+ if (count == buffer.length)
+ localFlush ();
+ }
+ }
+ }
+
+ // This should only be called with the lock held.
+ private void localFlush () throws IOException
+ {
+ if (count > 0)
+ {
+ out.write(buffer, 0, count);
+ count = 0;
+ }
+ }
+}
Added: trunk/core/src/classpath/java/java/io/ByteArrayInputStream.java
===================================================================
--- trunk/core/src/classpath/java/java/io/ByteArrayInputStream.java (rev 0)
+++ trunk/core/src/classpath/java/java/io/ByteArrayInputStream.java 2006-12-12 21:09:56 UTC (rev 2896)
@@ -0,0 +1,251 @@
+/* ByteArrayInputStream.java -- Read an array as a stream
+ Copyright (C) 1998, 1999, 2001, 2005 Free Software Foundation, Inc.
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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;
+
+/**
+ * This class permits an array of bytes to be read as an input stream.
+ *
+ * @author Warren Levy (wa...@cy...)
+ * @author Aaron M. Renn (ar...@ur...)
+ */
+public class ByteArrayInputStream extends InputStream
+{
+ /**
+ * The array that contains the data supplied during read operations
+ */
+ protected byte[] buf;
+
+ /**
+ * The array index of the next byte to be read from the buffer
+ * <code>buf</code>
+ */
+ protected int pos;
+
+ /**
+ * The currently marked position in the stream. This defaults to 0, so a
+ * reset operation on the stream resets it to read from array index 0 in
+ * the buffer - even if the stream was initially created with an offset
+ * greater than 0
+ */
+ protected int mark;
+
+ /**
+ * This indicates the maximum number of bytes that can be read from this
+ * stream. It is the array index of the position after the last valid
+ * byte in the buffer <code>buf</code>
+ */
+ protected int count;
+
+ /**
+ * Create a new ByteArrayInputStream that will read bytes from the passed
+ * in byte array. This stream will read from the beginning to the end
+ * of the array. It is identical to calling an overloaded constructor
+ * as <code>ByteArrayInputStream(buf, 0, buf.length)</code>.
+ * <p>
+ * Note that this array is not copied. If its contents are changed
+ * while this stream is being read, those changes will be reflected in the
+ * bytes supplied to the reader. Please use caution in changing the
+ * contents of the buffer while this stream is open.
+ *
+ * @param buffer The byte array buffer this stream will read from.
+ */
+ public ByteArrayInputStream(byte[] buffer)
+ {
+ this(buffer, 0, buffer.length);
+ }
+
+ /**
+ * Create a new ByteArrayInputStream that will read bytes from the
+ * passed in byte array. This stream will read from position
+ * <code>offset</code> in the array for a length of
+ * <code>length</code> bytes past <code>offset</code>. If the
+ * stream is reset to a position before <code>offset</code> then
+ * more than <code>length</code> bytes can be read from the stream.
+ * The <code>length</code> value should be viewed as the array index
+ * one greater than the last position in the buffer to read.
+ * <p>
+ * Note that this array is not copied. If its contents are changed
+ * while this stream is being read, those changes will be reflected in the
+ * bytes supplied to the reader. Please use caution in changing the
+ * contents of the buffer while this stream is open.
+ *
+ * @param buffer The byte array buffer this stream will read from.
+ * @param offset The index into the buffer to start reading bytes from
+ * @param length The number of bytes to read from the buffer
+ */
+ public ByteArrayInputStream(byte[] buffer, int offset, int length)
+ {
+ if (offset < 0 || length < 0 || offset > buffer.length)
+ throw new IllegalArgumentException();
+
+ buf = buffer;
+
+ count = offset + length;
+ if (count > buf.length)
+ count = buf.length;
+
+ pos = offset;
+ mark = pos;
+ }
+
+ /**
+ * This method returns the number of bytes available to be read from this
+ * stream. The value returned will be equal to <code>count - pos</code>.
+ *
+ * @return The number of bytes that can be read from this stream
+ * before blocking, which is all of them
+ */
+ public synchronized int available()
+ {
+ return count - pos;
+ }
+
+ /**
+ * This method sets the mark position in this stream to the current
+ * position. Note that the <code>readlimit</code> parameter in this
+ * method does nothing as this stream is always capable of
+ * remembering all the bytes int it.
+ * <p>
+ * Note that in this class the mark position is set by default to
+ * position 0 in the stream. This is in constrast to some other
+ * stream types where there is no default mark position.
+ *
+ * @param readLimit The number of bytes this stream must remember.
+ * This parameter is ignored.
+ */
+ public synchronized void mark(int readLimit)
+ {
+ // readLimit is ignored per Java Class Lib. book, p.220.
+ mark = pos;
+ }
+
+ /**
+ * This method overrides the <code>markSupported</code> method in
+ * <code>InputStream</code> in order to return <code>true</code> -
+ * indicating that this stream class supports mark/reset
+ * functionality.
+ *
+ * @return <code>true</code> to indicate that this class supports
+ * mark/reset.
+ */
+ public boolean markSupported()
+ {
+ return true;
+ }
+
+ /**
+ * This method reads one byte from the stream. The <code>pos</code>
+ * counter is advanced to the next byte to be read. The byte read is
+ * returned as an int in the range of 0-255. If the stream position
+ * is already at the end of the buffer, no by...
[truncated message content] |
