OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix for PR java.io/204:

Browse Source 
* java/io/PipedInputStream.java, java/io/PipedReader.java,
	java/io/PipedOutputStream.java, java/io/PipedWriter.java: Imported
	from Classpath.

From-SVN: r33300
This commit is contained in:
Tom Tromey 2000-04-21 01:18:16 +00:00 committed by Tom Tromey
parent 21caf59006
commit d3474943bf
5 changed files with 1433 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libjava/ChangeLog
View File

@ -1,5 +1,10 @@
2000-04-20 Tom Tromey <tromey@cygnus.com>
Fix for PR java.io/204:
* java/io/PipedInputStream.java, java/io/PipedReader.java,
java/io/PipedOutputStream.java, java/io/PipedWriter.java: Imported
from Classpath.
Fix for PR libgcj/212:
* gcj/javaprims.h (_Jv_word, _Jv_word2): Removed definitions.
* include/jvm.h (_Jv_word, _Jv_word2): Define.

760
libjava/java/io/PipedInputStream.java
View File

@ -1,242 +1,550 @@
/* Copyright (C) 1998, 1999 Free Software Foundation
/* PipedInputStream.java -- Input stream that reads from an output stream
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
This file is part of libgcj.
This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
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.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.io;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date October 29, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct.
*/
* This class is an input stream that reads its bytes from an output stream
* to which it is connected.
* <p>
* Data is read and written to an internal buffer. It is highly recommended
* that the <code>PipedInputStream</code> and connected <code>PipedOutputStream</code>
* be part of different threads. If they are not, there is a possibility
* that the read and write operations could deadlock their thread.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class PipedInputStream extends InputStream
{
/* The size of the pipe's circular input buffer. */
protected static final int PIPE_SIZE = 1024;
/* The circular buffer into which incoming data is placed. */
protected byte[] buffer;
/*************************************************************************/
/* The index in the buffer at which the next byte of data will be stored. */
protected int in = -1;
/*
* Class Variables
*/
/* The index in the buffer at which the next byte of data will be read. */
protected int out = 0;
/**
* The size of the internal buffer used for input/output. Note that this
* can be overriden by setting the system property
* <code>gnu.java.io.PipedInputStream.pipe_size</code> to the desired size shown
* in bytes. This is not a standard part of the class library. Note that
* since this variable is <code>final</code>, it cannot be changed to refect
* the size specified in the property.
* <p>
* The value for this variable is 2048.
*/
protected static final int PIPE_SIZE = 2048;
/* The output stream this is connected to; used to check for errors. */
private PipedOutputStream po = null;
/**
* This is the real pipe size. It defaults to PIPE_SIZE, unless overridden
* by use of the system property <code>gnu.java.io.PipedInputStream.pipe_size</code>.
*/
private static int pipe_size;
/* Flag to indicate that the output stream was closed. */
private boolean outClosed = false;
/**
* This variable indicates whether or not the <code>read()</code> method will attempt
* return a short count if this will possibly keep the stream from blocking.
* The default for this is <code>false</code> because that is what what the JDK seems
* to imply in its javadocs. We set this to <code>false</code> if the system
* property <code>gnu.java.io.try_not_to_block</code> is set.
*/
private static boolean try_not_to_block = false;
public PipedInputStream(PipedOutputStream src) throws IOException
{
buffer = new byte[PIPE_SIZE];
connect(src);
}
static
{
pipe_size = Integer.getInteger("gnu.java.io.PipedInputStream.pipe_size",
PIPE_SIZE).intValue();
public PipedInputStream()
{
buffer = new byte[PIPE_SIZE];
}
public synchronized int available() throws IOException
{
if (in < 0)
return 0;
if (in > out)
return in - out;
// Buffer has wrapped around.
return buffer.length - out + in;
}
public void close() throws IOException
{
buffer = null;
po = null;
// Mark as empty for available method.
in = -1;
}
public void connect(PipedOutputStream src) throws IOException
{
if (buffer == null)
throw new IOException("pipe closed");
if (po != null)
if (po == src)
return;
else
throw new IOException("pipe already connected");
po = src;
try
{
src.connect(this);
}
catch (IOException ex)
{
po = null;
throw ex;
}
}
public synchronized int read() throws IOException
{
// TBD: Spec says to throw IOException if thread writing to output stream
// died. What does this really mean? Theoretically, multiple threads
// could be writing to this object. Do you track the first, last, or
// all of them?
if (po == null)
if (buffer == null)
throw new IOException("pipe closed");
else
throw new IOException("pipe unconnected");
// Block until there's something to read or output stream was closed.
while (in < 0)
try
{
if (outClosed)
return -1;
wait();
}
catch (InterruptedException ex)
{
throw new InterruptedIOException();
}
// Let other threads know there's room to write now.
notifyAll();
int retval = buffer[out++] & 0xFF;
// Wrap back around if at end of the array.
if (out >= buffer.length)
out = 0;
// When the last byte available is read, mark the buffer as empty.
if (out == in)
{
in = -1;
out = 0;
}
return retval;
}
public synchronized int read(byte[] b, int off, int len) throws IOException
{
if (off < 0 || len < 0 || off + len > b.length)
throw new ArrayIndexOutOfBoundsException();
// TBD: Spec says to throw IOException if thread writing to output stream
// died. What does this really mean? Theoretically, multiple threads
// could be writing to this object. Do you track the first, last, or
// all of them?
if (po == null)
if (buffer == null)
throw new IOException("pipe closed");
else
throw new IOException("pipe unconnected");
// Block until there's something to read or output stream was closed.
while (in < 0)
try
{
if (outClosed)
return -1;
wait();
}
catch (InterruptedException ex)
{
throw new InterruptedIOException();
}
// Let other threads know there's room to write now.
notifyAll();
int numRead;
len = Math.min(len, available());
if (in <= out && len >= (numRead = buffer.length - out))
{
// Buffer has wrapped around; need to copy in 2 steps.
// Copy to the end of the buffer first; second copy may be of zero
// bytes but that is ok. Doing it that way saves having to check
// later if 'out' has grown to buffer.length.
System.arraycopy(buffer, out, b, off, numRead);
len -= numRead;
off += numRead;
out = 0;
}
else
numRead = 0;
System.arraycopy(buffer, out, b, off, len);
numRead += len;
out += len;
// When the last byte available is read, mark the buffer as empty.
if (out == in)
{
in = -1;
out = 0;
}
return numRead;
}
protected synchronized void receive(int b) throws IOException
{
if (buffer == null)
throw new IOException("pipe closed");
// TBD: Spec says to throw IOException if thread reading from input stream
// died. What does this really mean? Theoretically, multiple threads
// could be reading to this object (why else would 'read' be synchronized?).
// Do you track the first, last, or all of them?
if (b < 0)
{
outClosed = true;
notifyAll(); // In case someone was blocked in a read.
return;
}
// Block until there's room in the pipe.
while (in == out)
try
{
wait();
}
catch (InterruptedException ex)
{
throw new InterruptedIOException();
}
// Check if buffer is empty.
if (in < 0)
in = 0;
buffer[in++] = (byte) b;
// Wrap back around if at end of the array.
if (in >= buffer.length)
in = 0;
// Let other threads know there's something to read when this returns.
notifyAll();
}
String block_prop = System.getProperty("gnu.java.io.try_not_to_block");
if (block_prop != null)
try_not_to_block = true;
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the internal circular buffer used for storing bytes written
* to the pipe and from which bytes are read by this stream
*/
protected byte[] buffer = new byte[pipe_size];
/**
* The index into buffer where the bytes written byte the connected
* <code>PipedOutputStream</code> will be written. If this variables is less
* than 0, then the buffer is empty. If this variable is equal to
* <code>out</code>, then the buffer is full
*/
protected int in = -1;
/**
* This index into the buffer where bytes will be read from.
*/
protected int out = 0;
/**
* This variable is <code>true</code> if this object has ever been connected
* to a <code>PipedOutputStream</code>, and <code>false</code> otherwise. It is used
* to detect an attempt to connect an already connected stream or to
* otherwise use the stream before it is connected.
*/
private boolean ever_connected = false;
/**
* This variable is set to <code>true</code> if the <code>close()</code> method is
* called. This value is checked prevents a caller from re-opening the
* stream.
*/
private boolean closed = false;
/**
* This variable is the PipedOutputStream to which this stream is connected.
*/
PipedOutputStream src;
/**
* Used by <code>read()</code> to call an overloaded method
*/
private byte[] read_buf = new byte[1];
/*************************************************************************/
/*
* Constructors
*/
/**
* This constructor creates a new <code>PipedInputStream</code> that is not
* connected to a <code>PipedOutputStream</code>. It must be connected before
* bytes can be read from this stream.
*/
public
PipedInputStream()
{
return;
}
/*************************************************************************/
/**
* This constructor creates a new <code>PipedInputStream</code> and connects
* it to the passed in <code>PipedOutputStream</code>. The stream is then read
* for reading.
*
* @param src The <code>PipedOutputStream</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public
PipedInputStream(PipedOutputStream src) throws IOException
{
connect(src);
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This method connects this stream to the passed in <code>PipedOutputStream</code>.
* This stream is then ready for reading. If this stream is already
* connected or has been previously closed, then an exception is thrown
*
* @param src The <code>PipedOutputStream</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public synchronized void
connect(PipedOutputStream src) throws IOException
{
if (src == this.src)
return;
if (ever_connected)
throw new IOException("Already connected");
if (closed)
throw new IOException("Stream is closed and cannot be reopened");
src.connect(this);
ever_connected = true;
}
/*************************************************************************/
/**
* This methods closes the stream so that no more data can be read
* from it.
*
* @exception IOException If an error occurs
*/
public synchronized void
close() throws IOException
{
closed = true;
notifyAll();
}
/*************************************************************************/
/**
* This method returns the number of bytes that can be read from this stream
* before blocking could occur. This is the number of bytes that are
* currently unread in the internal circular buffer. Note that once this
* many additional bytes are read, the stream may block on a subsequent
* read, but it not guaranteed to block.
*
* @return The number of bytes that can be read before blocking might occur
*
* @exception IOException If an error occurs
*/
public synchronized int
available() throws IOException
{
if (in == -1)
return(0);
else if (in > out)
return(in - out);
else
return(in + (pipe_size - out));
}
/*************************************************************************/
/**
* Reads the next byte from the stream. The byte read is returned as
* and int in the range of 0-255. If a byte cannot be read because of an
* end of stream condition, -1 is returned. If the stream is already
* closed, an IOException will be thrown.
* <code>
* This method will block if no bytes are available to be read.
*
* @return The byte read or -1 if end of stream.
*
* @exception IOException If an error occurs
*/
public synchronized int
read() throws IOException
{
// Method operates by calling the multibyte overloaded read method
// Note that read_buf is an internal instance variable. I allocate it
// there to avoid constant reallocation overhead for applications that
// call this method in a loop at the cost of some unneeded overhead
// if this method is never called.
int bytes_read = read(read_buf, 0, read_buf.length);
if (bytes_read == -1)
return(-1);
else
return((read_buf[0] & 0xFF));
}
/*************************************************************************/
/**
* This method reads bytes from the stream into a caller supplied buffer.
* It starts storing bytes at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> bytes. Note that this method can actually
* read fewer than <code>len</code> bytes. The actual number of bytes read is
* returned. A -1 is returned to indicated that no bytes can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
* <p>
* This method will block if no bytes are available to be read.
*
* @param buf The buffer into which bytes will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of bytes to read.
*/
public synchronized int
read(byte[] buf, int offset, int len) throws IOException
{
if (!ever_connected)
throw new IOException("Not connected");
int bytes_read = 0;
for (;;)
{
// If there are bytes, take them
if (in != -1)
{
int desired_bytes = len - bytes_read;
// We are in a "wrap" condition
if (out > in)
{
if (desired_bytes > (pipe_size - out))
{
if (in == 0)
desired_bytes = (pipe_size - out) - 1;
else
desired_bytes = pipe_size - out;
System.arraycopy(buffer, out, buf, offset + bytes_read,
desired_bytes);
bytes_read += desired_bytes;
out += desired_bytes;
desired_bytes = len - bytes_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
else
{
if ((out + desired_bytes) == in)
--desired_bytes;
if (((out + desired_bytes) == pipe_size) && (in == 0))
desired_bytes = (pipe_size - out) - 1;
System.arraycopy(buffer, out, buf, offset + bytes_read,
desired_bytes);
bytes_read += desired_bytes;
out += desired_bytes;
desired_bytes = len - bytes_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
}
// We are in a "no wrap" or condition (can also be fall through
// from above
if (in > out)
{
if (desired_bytes >= ((in - out) - 1))
desired_bytes = (in - out) - 1;
System.arraycopy(buffer, out, buf, offset + bytes_read,
desired_bytes);
bytes_read += desired_bytes;
out += desired_bytes;
desired_bytes = len - bytes_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
}
// If we are done, return
if (bytes_read == len)
return(bytes_read);
// Return a short count if necessary
if (bytes_read < len)
if (try_not_to_block)
return(bytes_read);
// Handle the case where the end of stream was encountered.
if (closed)
{
// We never let in == out so there might be one last byte
// available that we have not copied yet.
if (in != -1)
{
buf[offset + bytes_read] = buffer[out];
in = -1;
++out;
++bytes_read;
}
if (bytes_read != 0)
return(bytes_read);
else
return(-1);
}
// Wait for a byte to be read
try
{
wait();
}
catch(InterruptedException e) { ; }
}
}
/*************************************************************************/
/**
* This method receives a byte of input from the source PipedOutputStream.
* If there is no data ready to be written, or if the internal circular
* buffer is full, this method blocks.
*
* *****What is this method really supposed to do *********
*/
protected synchronized void
receive(int byte_received) throws IOException
{
int orig_in = in;
for (;;)
{
// Wait for something to happen
try
{
wait();
}
catch(InterruptedException e) { ; }
// See if we woke up because the stream was closed on us
if (closed)
throw new IOException("Stream closed before receiving byte");
// See if a byte of data was received
if (in != orig_in)
return;
}
}
/*************************************************************************/
/**
* This method is used by the connected <code>PipedOutputStream</code> to
* write bytes into the buffer. It uses this method instead of directly
* writing the bytes in order to obtain ownership of the object's monitor
* for the purposes of calling <code>notify</code>.
*
* @param buf The array containing bytes to write to this stream
* @param offset The offset into the array to start writing from
* @param len The number of bytes to write.
*
* @exception IOException If an error occurs
*/
synchronized void
write(byte[] buf, int offset, int len) throws IOException
{
if (len <= 0)
return;
int total_written = 0;
while (total_written < len)
{
// If we are not at the end of the buffer with out = 0
if (!((in == (buffer.length - 1)) && (out == 0)))
{
// This is the "no wrap" situation
if ((in - 1) >= out)
{
int bytes_written = 0;
if ((buffer.length - in) > (len - total_written))
bytes_written = (len - total_written);
else if (out == 0)
bytes_written = (buffer.length - in) - 1;
else
bytes_written = (buffer.length - in);
if (bytes_written > 0)
System.arraycopy(buf, offset + total_written, buffer, in,
bytes_written);
total_written += bytes_written;
in += bytes_written;
if (in == buffer.length)
in = 0;
notifyAll();
}
// This is the "wrap" situtation
if ((out > in) && (total_written != len))
{
int bytes_written = 0;
// Do special processing if we are at the beginning
if (in == -1)
{
in = 0;
if (buffer.length > len)
bytes_written = len;
else
bytes_written = buffer.length - 1;
}
else if (((out - in) - 1) < (len - total_written))
{
bytes_written = (out - in) - 1;
}
else
{
bytes_written = len - total_written;
}
// If the buffer is full, wait for it to empty out
if ((out - 1) == in)
{
try
{
wait();
}
catch (InterruptedException e)
{
continue;
}
}
System.arraycopy(buf, offset + total_written, buffer, in,
bytes_written);
total_written += bytes_written;
in += bytes_written;
if (in == buffer.length)
in = 0;
notifyAll();
}
}
// Wait for some reads to occur before we write anything.
else
{
try
{
wait();
}
catch (InterruptedException e) { ; }
}
}
}
} // class PipedInputStream

272
libjava/java/io/PipedOutputStream.java
View File

@ -1,97 +1,209 @@
// PipedOutputStream.java - Write bytes to a pipe.
/* PipedOutputStream.java -- Write portion of piped streams.
Copyright (C) 1998 Free Software Foundation, Inc.
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.io;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date September 24, 1998
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* Status: Believed complete and correct.
*/
* This class writes its bytes to a <code>PipedInputStream</code> to
* which it is connected.
* <p>
* It is highly recommended that a <code>PipedOutputStream</code> and its
* connected <code>PipedInputStream</code> be in different threads. If
* they are in the same thread, read and write operations could deadlock
* the thread.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class PipedOutputStream extends OutputStream
{
public void close () throws IOException
{
closed = true;
// Notify PipedInputStream that there is no more data to be had.
destination.receive(-1);
}
/*************************************************************************/
public void connect (PipedInputStream dest) throws IOException
{
if (closed)
throw new IOException("pipe closed");
/*
* Instance Variables
*/
if (destination != null)
if (destination == dest)
return;
else
throw new IOException("pipe already connected");
/**
* This is the <code>PipedInputStream</code> to which this object
* is connected.
*/
private PipedInputStream snk;
destination = dest;
try
{
dest.connect(this);
}
catch (IOException ex)
{
destination = null;
throw ex;
}
}
/**
* This flag indicates whether or not this stream has ever been
* connected to an input stream
*/
private boolean ever_connected;
public synchronized void flush () throws IOException
{
// There doesn't seem to be anything to do here.
/**
* This flag indicates whether the <code>close</code> method has ever
* been called for this stream.
*/
private boolean closed;
// TBD: Should this maybe do a notifyAll as a way for the user
// to wake up the input stream to check for bytes to read? Shouldn't
// be necessary but if there aren't any bytes, other threads will just
// go blocak again anyway so it wouldn't hurt.
}
/*************************************************************************/
public PipedOutputStream ()
{
closed = false;
}
public PipedOutputStream (PipedInputStream dest) throws IOException
{
closed = false;
connect (dest);
}
public void write (int oneByte) throws IOException
{
if (closed)
throw new IOException ();
destination.receive(oneByte);
}
public void write (byte[] buffer, int offset, int count) throws IOException
{
if (closed)
throw new IOException ();
if (offset < 0 || count < 0 || offset + count > buffer.length)
throw new ArrayIndexOutOfBoundsException ();
for (int i = 0; i < count; ++i)
destination.receive (buffer[offset + i]);
}
// Instance variables.
private PipedInputStream destination;
private boolean closed;
/**
* This method initializes a new <code>PipedOutputStream</code> instance.
* This constructor creates an unconnected object. It must be connected
* to a <code>PipedInputStream</code> object using the <code>connect</code>
* method prior to writing any data or an exception will be thrown.
*/
public
PipedOutputStream()
{
; // Do Nothing
}
/*************************************************************************/
/**
* This method initializes a new <code>PipedOutputStream</code> instance
* to write to the specified <code>PipedInputStream</code>. This stream
* is then ready for writing.
*
* @param snk The <code>PipedInputStream</code> to connect this stream to.
*
* @exception IOException If an error occurs
*/
public
PipedOutputStream(PipedInputStream snk) throws IOException
{
connect(snk);
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method connects this object to the specified
* <code>PipedInputStream</code> object. This stream will then be ready
* for writing. If this stream is already connected or has been
* previously closed, then an exception is thrown.
*
* @param snk The <code>PipedInputStream</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public synchronized void
connect(PipedInputStream snk) throws IOException
{
if (snk == this.snk)
return;
if (ever_connected)
throw new IOException("Already connected");
if (closed)
throw new IOException("Stream is closed and cannot be reopened");
this.snk = snk;
ever_connected = true;
snk.src = this;
snk.connect(this);
}
/*************************************************************************/
/**
* This method closes this stream so that no more data can be written
* to it. Any further attempts to write to this stream may throw an
* exception
*
* @exception IOException If an error occurs
*/
public synchronized void
close() throws IOException
{
closed = true;
snk.close();
notifyAll();
}
/*************************************************************************/
/**
* This method writes a single byte of date to the stream. Note that
* this method will block if the <code>PipedInputStream</code> to which
* this object is connected has a full buffer.
*
* @param b The byte of data to be written, passed as an <code>int</code>.
*
* @exception IOException If an error occurs
*/
public synchronized void
write(int b) throws IOException
{
byte[] buf = new byte[1];
buf[0] = (byte)(b & 0xFF);
snk.write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method writes <code>len</code> bytes of data from the byte array
* <code>buf</code> starting at index <code>offset</code> in the array
* to the stream. Note that this method will block if the
* <code>PipedInputStream</code> to which this object is connected has
* a buffer that cannot hold all of the bytes to be written.
*
* @param buf The array containing bytes to write to thes stream.
* @param offset The index into the array to start writing bytes from.
* @param len The number of bytes to write.
*
* @exception IOException If an error occurs
*/
public void
write(byte[] buf, int offset, int len) throws IOException
{
snk.write(buf, 0, len);
}
/*************************************************************************/
/**
* This method flushes any unwritten bytes to the output and notifies
* any waiting readers that the pipe is ready to be read.
*
* @exception IOException If an error occurs.
*/
public void
flush() throws IOException
{
return;
}
} // class PipedOutputStream

695
libjava/java/io/PipedReader.java
View File

@ -1,210 +1,519 @@
// PipedReader.java - Piped character stream.
/* PipedReader.java -- Input stream that reads from an output stream
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
/* Copyright (C) 1998, 1999 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.io;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date September 25, 1998
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* Status: Complete to 1.1.
*/
* This class is an input stream that reads its chars from an output stream
* to which it is connected.
* <p>
* Data is read and written to an internal buffer. It is highly recommended
* that the <code>PipedReader</code> and connected <code>PipedWriter</code>
* be part of different threads. If they are not, there is a possibility
* that the read and write operations could deadlock their thread.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class PipedReader extends Reader
{
public void close () throws IOException
{
closed = true;
}
public void connect (PipedWriter src) throws IOException
{
if (closed)
throw new IOException ("already closed");
if (writer != null)
{
if (writer == src)
return;
throw new IOException ("already connected");
}
try
{
writer = src;
writer.connect(this);
}
catch (IOException e)
{
writer = null;
throw e;
}
}
/*************************************************************************/
public PipedReader ()
{
super ();
writer = null;
closed = false;
in = -1;
out = 0;
pipeBuffer = new char[1024];
}
/*
* Class Variables
*/
public PipedReader (PipedWriter src) throws IOException
{
super ();
closed = false;
in = -1;
out = 0;
pipeBuffer = new char[1024];
connect (src);
}
/**
* The size of the internal buffer used for input/output. Note that this
* can be overriden by setting the system property
* <code>gnu.java.io.PipedReader.pipe_size</code> to the desired size shown
* in chars. This is not a standard part of the class library. Note that
* since this variable is <code>final</code>, it cannot be changed to refect
* the size specified in the property.
* <p>
* The value for this variable is 2048.
*/
private static final int PIPE_SIZE = 2048;
public int read (char buf[], int offset, int count) throws IOException
{
if (closed)
throw new IOException ("closed");
if (count < 0)
throw new ArrayIndexOutOfBoundsException ();
int toCopy = count;
synchronized (lock)
{
while (toCopy > 0)
{
// Wait for data in the pipe. If the writer is closed and
// no data has been copied into the output buffer, return
// the magic EOF number.
while (in == -1)
{
if (writer.isClosed())
{
if (toCopy < count)
return count - toCopy;
return -1;
}
/**
* This is the real pipe size. It defaults to PIPE_SIZE, unless overridden
* by use of the system property <code>gnu.java.io.PipedReader.pipe_size</code>.
*/
private static int pipe_size;
// Note that JCL doesn't say this is the right thing
// to do. Still, it feels right, and we must deal
// with an interrupt somehow.
try
{
lock.wait();
}
catch (InterruptedException e)
{
InterruptedIOException io
= new InterruptedIOException (e.getMessage());
io.bytesTransferred = count - toCopy;
throw io;
}
}
// Now copy some data from pipe into user buffer.
int len;
if (in < out)
len = pipeBuffer.length - out;
else
len = in - out;
len = len > toCopy ? toCopy : len;
System.arraycopy(pipeBuffer, out, buf, offset, len);
out += len;
if (out == pipeBuffer.length)
out = 0;
toCopy -= len;
offset += len;
// If we've read all the data, then reset so that we know
// there is nothing left to be read.
if (in == out)
in = -1;
// Tell anybody waiting for space in the buffer.
lock.notifyAll();
}
}
return count;
}
/**
* This variable indicates whether or not the <code>read()</code> method will attempt
* return a short count if this will possibly keep the stream from blocking.
* The default for this is <code>false</code> because that is what what the JDK seems
* to imply in its javadocs. We set this to <code>false</code> if the system
* property <code>gnu.java.io.try_not_to_block</code> is set.
*/
private static boolean try_not_to_block = false;
void receive (char buf[], int offset, int count) throws IOException
{
if (count < 0)
throw new ArrayIndexOutOfBoundsException ();
int original = count;
synchronized (lock)
{
while (count > 0)
{
// Wait until there is some space in the buffer.
while (in == out)
{
try
{
lock.wait();
}
catch (InterruptedException e)
{
// Turn interrupts into IO interrupts.
InterruptedIOException io
= new InterruptedIOException (e.getMessage());
io.bytesTransferred = original - count;
throw io;
}
}
static
{
pipe_size = Integer.getInteger("gnu.java.io.PipedReader.pipe_size",
PIPE_SIZE).intValue();
// Compute destination in the pipe.
int base, len;
if (in == -1)
{
base = 0;
len = pipeBuffer.length;
}
else if (in < out)
{
base = in;
len = out - in;
}
else
{
base = in;
len = pipeBuffer.length - in;
}
int copyLen = len > count ? count : len;
// Copy data and update local state.
System.arraycopy(buf, offset, pipeBuffer, base, copyLen);
in = base + copyLen;
if (in == pipeBuffer.length)
in = 0;
count -= copyLen;
offset += copyLen;
// Tell anybody waiting for data.
lock.notifyAll();
}
}
}
boolean isClosed ()
{
return closed;
}
// The associated writer.
private PipedWriter writer;
// True if this reader has been closed.
boolean closed;
// Index of next character to overwrite when receive() is called.
// If -1, then that means the buffer is empty.
private int in;
// Index of next character to return from read().
private int out;
// The pipe buffer itself.
private char[] pipeBuffer;
String block_prop = System.getProperty("gnu.java.io.try_not_to_block");
if (block_prop != null)
try_not_to_block = true;
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the internal circular buffer used for storing chars written
* to the pipe and from which chars are read by this stream
*/
private char[] buffer = new char[pipe_size];
/**
* The index into buffer where the chars written char the connected
* <code>PipedWriter</code> will be written. If this variables is less
* than 0, then the buffer is empty. If this variable is equal to
* <code>out</code>, then the buffer is full
*/
private int in = -1;
/**
* This index into the buffer where chars will be read from.
*/
private int out = 0;
/**
* This variable is <code>true</code> if this object has ever been connected
* to a <code>PipedWriter</code>, and <code>false</code> otherwise. It is used
* to detect an attempt to connect an already connected stream or to
* otherwise use the stream before it is connected.
*/
private boolean ever_connected = false;
/**
* This variable is set to <code>true</code> if the <code>close()</code> method is
* called. This value is checked prevents a caller from re-opening the
* stream.
*/
private boolean closed = false;
/**
* This variable is the PipedWriter to which this stream is connected.
*/
PipedWriter src;
/*************************************************************************/
/*
* Constructors
*/
/**
* This constructor creates a new <code>PipedReader</code> that is not
* connected to a <code>PipedWriter</code>. It must be connected before
* chars can be read from this stream.
*/
public
PipedReader()
{
return;
}
/*************************************************************************/
/**
* This constructor creates a new <code>PipedReader</code> and connects
* it to the passed in <code>PipedWriter</code>. The stream is then read
* for reading.
*
* @param src The <code>PipedWriter</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public
PipedReader(PipedWriter src) throws IOException
{
connect(src);
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This method connects this stream to the passed in <code>PipedWriter</code>.
* This stream is then ready for reading. If this stream is already
* connected or has been previously closed, then an exception is thrown
*
* @param src The <code>PipedWriter</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public void
connect(PipedWriter src) throws IOException
{
if (src == this.src)
return;
if (ever_connected)
throw new IOException("Already connected");
if (closed)
throw new IOException("Stream is closed and cannot be reopened");
synchronized (lock) {
src.connect(this);
ever_connected = true;
} // synchronized
}
/*************************************************************************/
/**
* This methods closes the stream so that no more data can be read
* from it.
*
* @exception IOException If an error occurs
*/
public void
close() throws IOException
{
synchronized (lock) {
closed = true;
notifyAll();
} // synchronized
}
/*************************************************************************/
/**
* This method determines whether or not this stream is ready to be read.
* If this metho returns <code>false</code> an attempt to read may (but is
* not guaranteed to) block.
*
* @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
{
if (in == -1)
return(false);
if (out == (in - 1))
return(false);
if ((out == pipe_size) && (in == 0))
return(false);
return(true);
}
/*************************************************************************/
/**
* This method reads a single char from the pipe and returns it as an
* <code>int</code>.
* <p>
* This method will block if no chars are available to be read.
*
* @return An char read from the pipe, or -1 if the end of stream is
* reached.
*
* @exception IOException If an error occurs.
*/
public int
read() throws IOException
{
char[] buf = new char[1];
return(read(buf, 0, buf.length));
}
/*************************************************************************/
/**
* This method reads chars from the stream into a caller supplied buffer.
* It starts storing chars at position <code>offset</code> into the buffer and
* reads a maximum of <cod>>len</code> chars. Note that this method can actually
* read fewer than <code>len</code> chars. The actual number of chars read is
* returned. A -1 is returned to indicated that no chars can be read
* because the end of the stream was reached. If the stream is already
* closed, a -1 will again be returned to indicate the end of the stream.
* <p>
* This method will block if no chars are available to be read.
*
* @param buf The buffer into which chars will be stored
* @param offset The index into the buffer at which to start writing.
* @param len The maximum number of chars to read.
*/
public int
read(char[] buf, int offset, int len) throws IOException
{
if (!ever_connected)
throw new IOException("Not connected");
synchronized (lock) {
int chars_read = 0;
for (;;)
{
// If there are chars, take them
if (in != -1)
{
int desired_chars = len - chars_read;
// We are in a "wrap" condition
if (out > in)
{
if (desired_chars > (pipe_size - out))
{
if (in == 0)
desired_chars = (pipe_size - out) - 1;
else
desired_chars = pipe_size - out;
System.arraycopy(buffer, out, buf, offset + chars_read,
desired_chars);
chars_read += desired_chars;
out += desired_chars;
desired_chars = len - chars_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
else
{
if ((out + desired_chars) == in)
--desired_chars;
if (((out + desired_chars) == pipe_size) && (in == 0))
desired_chars = (pipe_size - out) - 1;
System.arraycopy(buffer, out, buf, offset + chars_read,
desired_chars);
chars_read += desired_chars;
out += desired_chars;
desired_chars = len - chars_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
}
// We are in a "no wrap" or condition (can also be fall through
// from above
if (in > out)
{
if (desired_chars >= ((in - out) - 1))
desired_chars = (in - out) - 1;
System.arraycopy(buffer, out, buf, offset + chars_read,
desired_chars);
chars_read += desired_chars;
out += desired_chars;
desired_chars = len - chars_read;
if (out == pipe_size)
out = 0;
notifyAll();
}
}
// If we are done, return
if (chars_read == len)
return(chars_read);
// Return a short count if necessary
if (chars_read < len)
if (try_not_to_block)
return(chars_read);
// Handle the case where the end of stream was encountered.
if (closed)
{
// We never let in == out so there might be one last char
// available that we have not copied yet.
if (in != -1)
{
buf[offset + chars_read] = buffer[out];
in = -1;
++out;
++chars_read;
}
if (chars_read != 0)
return(chars_read);
else
return(-1);
}
// Wait for a char to be read
try
{
wait();
}
catch(InterruptedException e) { ; }
}
} // synchronized
}
/*************************************************************************/
/**
* This method is used by the connected <code>PipedWriter</code> to
* write chars into the buffer. It uses this method instead of directly
* writing the chars in order to obtain ownership of the object's monitor
* for the purposes of calling <code>notify</code>.
*
* @param buf The array containing chars to write to this stream
* @param offset The offset into the array to start writing from
* @param len The number of chars to write.
*
* @exception IOException If an error occurs
*/
void
write(char[] buf, int offset, int len) throws IOException
{
if (len <= 0)
return;
synchronized (lock) {
int total_written = 0;
while (total_written < len)
{
// If we are not at the end of the buffer with out = 0
if (!((in == (buffer.length - 1)) && (out == 0)))
{
// This is the "no wrap" situation
if ((in - 1) >= out)
{
int chars_written = 0;
if ((buffer.length - in) > (len - total_written))
chars_written = (len - total_written);
else if (out == 0)
chars_written = (buffer.length - in) - 1;
else
chars_written = (buffer.length - in);
if (chars_written > 0)
System.arraycopy(buf, offset + total_written, buffer, in,
chars_written);
total_written += chars_written;
in += chars_written;
if (in == buffer.length)
in = 0;
notifyAll();
}
// This is the "wrap" situtation
if ((out > in) && (total_written != len))
{
int chars_written = 0;
// Do special processing if we are at the beginning
if (in == -1)
{
in = 0;
if (buffer.length > len)
chars_written = len;
else
chars_written = buffer.length - 1;
}
else if (((out - in) - 1) < (len - total_written))
{
chars_written = (out - in) - 1;
}
else
{
chars_written = len - total_written;
}
// If the buffer is full, wait for it to empty out
if ((out - 1) == in)
{
try
{
wait();
}
catch (InterruptedException e)
{
continue;
}
}
System.arraycopy(buf, offset + total_written, buffer, in,
chars_written);
total_written += chars_written;
in += chars_written;
if (in == buffer.length)
in = 0;
notifyAll();
}
}
// Wait for some reads to occur before we write anything.
else
{
try
{
wait();
}
catch (InterruptedException e) { ; }
}
}
} // synchronized
}
} // class PipedReader

271
libjava/java/io/PipedWriter.java
View File

@ -1,88 +1,217 @@
// PipedWriter.java - Piped character stream.
/* PipedWriter.java -- Write portion of piped streams.
Copyright (C) 1998 Free Software Foundation, Inc.
/* Copyright (C) 1998, 1999 Free Software Foundation
This file is part of GNU Classpath.
This file is part of libgcj.
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.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.io;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date September 25, 1998
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
* Status: Complete to 1.1.
*/
* This class writes its chars to a <code>PipedReader</code> to
* which it is connected.
* <p>
* It is highly recommended that a <code>PipedWriter</code> and its
* connected <code>PipedReader</code> be in different threads. If
* they are in the same thread, read and write operations could deadlock
* the thread.
*
* @version 0.0
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class PipedWriter extends Writer
{
public void close () throws IOException
{
closed = true;
}
public void connect (PipedReader sink) throws IOException
{
if (closed)
throw new IOException ("already closed");
if (reader != null)
{
if (reader == sink)
return;
throw new IOException ("already connected");
}
try
{
reader = sink;
reader.connect(this);
}
catch (IOException e)
{
reader = null;
throw e;
}
}
/*************************************************************************/
public void flush () throws IOException
{
// We'll throw an exception if we're closed, but there's nothing
// else to do here.
if (closed)
throw new IOException ("closed");
}
/*
* Instance Variables
*/
public PipedWriter ()
{
super ();
closed = false;
}
/**
* This is the <code>PipedReader</code> to which this object
* is connected.
*/
private PipedReader snk;
public PipedWriter (PipedReader sink) throws IOException
{
super ();
closed = false;
connect (sink);
}
/**
* This flag indicates whether or not this stream has ever been
* connected to an input stream
*/
private boolean ever_connected;
public void write (char buffer[], int offset, int count) throws IOException
{
if (closed)
throw new IOException ("closed");
reader.receive(buffer, offset, count);
}
/**
* This flag indicates whether the <code>close</code> method has ever
* been called for this stream.
*/
private boolean closed;
boolean isClosed ()
{
return closed;
}
/*************************************************************************/
// The associated reader.
private PipedReader reader;
private boolean closed;
/**
* This method initializes a new <code>PipedWriter</code> instance.
* This constructor creates an unconnected object. It must be connected
* to a <code>PipedReader</code> object using the <code>connect</code>
* method prior to writing any data or an exception will be thrown.
*/
public
PipedWriter()
{
; // Do Nothing
}
/*************************************************************************/
/**
* This method initializes a new <code>PipedWriter</code> instance
* to write to the specified <code>PipedReader</code>. This stream
* is then ready for writing.
*
* @param snk The <code>PipedReader</code> to connect this stream to.
*
* @exception IOException If an error occurs
*/
public
PipedWriter(PipedReader snk) throws IOException
{
connect(snk);
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method connects this object to the specified
* <code>PipedReader</code> object. This stream will then be ready
* for writing. If this stream is already connected or has been
* previously closed, then an exception is thrown.
*
* @param snk The <code>PipedReader</code> to connect this stream to
*
* @exception IOException If an error occurs
*/
public void
connect(PipedReader snk) throws IOException
{
if (snk == this.snk)
return;
if (ever_connected)
throw new IOException("Already connected");
if (closed)
throw new IOException("Stream is closed and cannot be reopened");
synchronized (lock) {
this.snk = snk;
ever_connected = true;
snk.src = this;
snk.connect(this);
} // synchronized
}
/*************************************************************************/
/**
* This method closes this stream so that no more data can be written
* to it. 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) {
closed = true;
snk.close();
notifyAll();
} // synchronized
}
/*************************************************************************/
/**
* This methods writes a single byte of data to the pipe. This call may
* block if the pipe is full.
*
* @param c The <code>char</code> to write, passed as an <code>int</code>.
*
* @exception IOException If an error occurs.
*/
public void
write(int c) throws IOException
{
char[] buf = new char[1];
buf[0] = (char)c;
write(buf, 0, buf.length);
}
/*************************************************************************/
/**
* This method writes <code>len</code> chars of data from the char array
* <code>buf</code> starting at index <code>offset</code> in the array
* to the stream. Note that this method will block if the
* <code>PipedReader</code> to which this object is connected has
* a buffer that cannot hold all of the chars to be written.
*
* @param buf The array containing chars to write to thes stream.
* @param offset The index into the array to start writing chars 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
{
snk.write(buf, 0, len);
}
/*************************************************************************/
/**
* This method flushes any unwritten chars to the underlying output
* sink. This method does nothing in this class because this class does
* not buffer any chars.
*
* @exception IOException If an error occurs
*/
public void
flush() throws IOException
{
; // Do Nothing
}
} // class PipedWriter