1 files changed, 291 insertions, 458 deletions

diff --git a/libjava/java/io/PipedReader.java b/libjava/java/io/PipedReader.java
index f877a6a..6e4e104 100644
--- a/libjava/java/io/PipedReader.java
+++ b/libjava/java/io/PipedReader.java
@@ -1,5 +1,5 @@
-/* PipedReader.java -- Input stream that reads from an output stream
-   Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+/* PipedReader.java -- Read portion of piped character streams.
+   Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -24,479 +24,312 @@ 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;
 
+// NOTE: This implementation is very similar to that of PipedInputStream. 
+// If you fix a bug in here, chances are you should make a similar change to 
+// the PipedInputStream code.
+
 /**
-  * This class is an input stream that reads its chars from an output stream
-  * to which it is connected. 
+  * An input stream that reads characters from a piped writer 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
+  * @specnote The JDK implementation appears to have some undocumented 
+  *           functionality where it keeps track of what thread is writing
+  *           to pipe and throws an IOException if that thread susequently
+  *           dies. This behaviour seems dubious and unreliable - we don't
+  *           implement it.
   *
   * @author Aaron M. Renn (arenn@urbanophile.com)
   */
 public class PipedReader extends Reader
 {
-
-/*************************************************************************/
-
-/*
- * Class Variables
- */
-
-/**
-  * 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;
-
-/**
-  * 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;
-
-static
-{
-  pipe_size =  Integer.getInteger("gnu.java.io.PipedReader.pipe_size",
-                                  PIPE_SIZE).intValue();
-}
-
-/*************************************************************************/
-
-/*
- * 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
-}
-
-/*************************************************************************/
-
-/**
+  /** PipedWriter to which this is connected. Null only if this 
+    * Reader hasn't been connected yet. */
+  PipedWriter source;
+
+  /** Set to true if close() has been called on this Reader. */
+  boolean closed;
+
+  /**
+    * The size of the internal buffer used for input/output.
+    */
+  static final int PIPE_SIZE = 2048;
+
+  /**
+    * This is the internal circular buffer used for storing chars written
+    * to the pipe and from which chars are read by this stream
+    */
+  char[] buffer = new char[PIPE_SIZE];
+
+  /**
+    * The index into buffer where the next char from the connected
+    * <code>PipedWriter</code> will be written. If this variable is 
+    * equal to <code>out</code>, then the buffer is full. If set to < 0,
+    * the buffer is empty.
+    */
+  int in = -1;
+
+  /**
+    * This index into the buffer where chars will be read from.
+    */
+  int out = 0;
+
+  /** Buffer used to implement single-argument read/receive */
+  char[] read_buf = new char[1];
+
+  /**
+    * 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()
+  {
+  }
+
+  /**
+    * This constructor creates a new <code>PipedReader</code> and connects
+    * it to the passed in <code>PipedWriter</code>. The stream is then 
+    * ready for reading.
+    *
+    * @param source The <code>PipedWriter</code> to connect this stream to
+    *
+    * @exception IOException If <code>source</code> is already connected.
+    */
+  public PipedReader(PipedWriter source) throws IOException
+  {
+    connect(source);
+  }
+
+  /**
+    * 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 this PipedReader or <code>source</code> 
+    *                        has been connected already.
+    */
+  public void connect(PipedWriter source) throws IOException
+  {
+    // The JDK (1.3) does not appear to check for a previously closed 
+    // connection here.
+    
+    if (this.source != null || source.sink != null)
+      throw new IOException ("Already connected");
+    
+    source.sink = this;
+    this.source = source;
+  }
+  
+  /**
+    * This method is used by the connected <code>PipedWriter</code> to
+    * write chars into the buffer.
+    *
+    * @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
+    * @specnote This code should be in PipedWriter.write, but we
+    *           put it here in order to support that bizarre recieve(int)
+    *           method.
+    */  
+  synchronized void receive(char[] buf, int offset, int len)
+    throws IOException
+  {
+    if (closed)
+      throw new IOException ("Pipe closed");
+
+    int bufpos = offset;
+    int copylen;
+    
+    while (len > 0)
+      {
+        try
+	  {
+	    while (in == out)
+	      {
+		// The pipe is full. Wake up any readers and wait for them.
+		notifyAll();
+		wait();
+		// The pipe could have been closed while we were waiting.
+	        if (closed)
+		  throw new IOException ("Pipe closed");
+	      }
+	  }
+	catch (InterruptedException ix)
+	  {
+            throw new InterruptedIOException ();
+	  }
+
+	if (in < 0) // The pipe is empty.
+	  in = 0;
+	
+	// Figure out how many chars from buf can be copied without 
+	// overrunning out or going past the length of the buffer.
+	if (in < out)
+	  copylen = Math.min (len, out - in);
+	else
+	  copylen = Math.min (len, buffer.length - in);
+
+	// Copy chars until the pipe is filled, wrapping if neccessary.
+	System.arraycopy(buf, bufpos, buffer, in, copylen);
+	len -= copylen;
+	bufpos += copylen;
+	in += copylen;
+	if (in == buffer.length)
+	  in = 0;
+      }
+    // Notify readers that new data is in the pipe.
+    notifyAll();
+  }
+  
+  /**
+    * 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() throws IOException
+  {
+    // Method operates by calling the multichar 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 r = read(read_buf, 0, 1);
+
+    if (r == -1)
+      return -1;
+    else
+      return read_buf[0];
+  }
+  
+  /**
+    * This method reads characters 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 - ie close() was called on the
+    * connected PipedWriter.
+    * <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.
+    *
+    * @exception IOException If <code>close()/code> was called on this Piped
+    *                        Reader.
+    */  
+  public synchronized int read(char[] buf, int offset, int len)
+    throws IOException
+  {
+    if (source == null)
+      throw new IOException ("Not connected");
+    if (closed)
+      throw new IOException ("Pipe closed");
+
+    // If the buffer is empty, wait until there is something in the pipe 
+    // to read.
+    try
+      {
+	while (in < 0)
+	  {
+	    if (source.closed)
+	      return -1;
+	    wait();
+	  }
+      }
+    catch (InterruptedException ix)
+      {
+        throw new InterruptedIOException();
+      }
+    
+    int total = 0;
+    int copylen;
+    
+    while (true)
+      {
+	// Figure out how many chars from the pipe can be copied without 
+	// overrunning in or going past the length of buf.
+	if (out < in)
+	  copylen = Math.min (len, in - out);
+	else
+	  copylen = Math.min (len, buffer.length - out);
+
+        System.arraycopy (buffer, out, buf, offset, copylen);
+	offset += copylen;
+	len -= copylen;
+	out += copylen;
+	total += copylen;
+	
+	if (out == buffer.length)
+	  out = 0;
+	
+	if (out == in)
+	  {
+	    // Pipe is now empty.
+	    in = -1;
+	    out = 0;
+	  }
+
+        // If output buffer is filled or the pipe is empty, we're done.
+	if (len == 0 || in == -1)
+	  {
+	    // Notify any waiting Writer that there is now space
+	    // to write.
+	    notifyAll();
+	    return total;
+	  }
+      }
+  }
+  
+  public synchronized boolean ready() throws IOException
+  {
+    // The JDK 1.3 implementation does not appear to check for the closed or 
+    // unconnected stream conditions here.
+    
+    if (in < 0)
+      return false;
+    
+    int count;
+    if (out < in)
+      count = in - out;
+    else
+      count = (buffer.length - out) - in;
+    
+    return (count > 0);
+  }
+  
+  /**
   * 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 > 0 && chars_read < len)
-	    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
+  public synchronized void close() throws IOException
+  {
+    closed = true;
+    // Wake any thread which may be in receive() waiting to write data.
+    notifyAll();
+  }
 }
-
-} // class PipedReader
-