+++ /dev/null
-/* PipedInputStream.java -- Read portion of piped streams.
- 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., 59 Temple Place, Suite 330, Boston, MA
-02111-1307 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library. Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module. An independent module is a module which is not derived from
-or based on this library. If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so. If you do not wish to do so, delete this
-exception statement from your version. */
-
-// NOTE: This implementation is very similar to that of PipedReader. If you
-// fix a bug in here, chances are you should make a similar change to the
-// PipedReader code.
-
-package java.io;
-
-/**
- * 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, the read and write
- * operations could deadlock their thread.
- *
- * @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 PipedInputStream extends InputStream
-{
- /** PipedOutputStream to which this is connected. Null only if this
- * InputStream hasn't been connected yet. */
- PipedOutputStream source;
-
- /** Set to true if close() has been called on this InputStream. */
- boolean closed;
-
- /**
- * The size of the internal buffer used for input/output.
- */
- protected static final int PIPE_SIZE = 2048;
-
- /**
- * 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 next byte from the connected
- * <code>PipedOutputStream</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.
- */
- protected int in = -1;
-
- /**
- * This index into the buffer where bytes will be read from.
- */
- protected int out = 0;
-
- /** Buffer used to implement single-argument read/receive */
- private byte[] read_buf = new byte[1];
-
- /**
- * 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()
- {
- }
-
- /**
- * This constructor creates a new <code>PipedInputStream</code> and connects
- * it to the passed in <code>PipedOutputStream</code>. The stream is then
- * ready for reading.
- *
- * @param source The <code>PipedOutputStream</code> to connect this stream to
- *
- * @exception IOException If <code>source</code> is already connected.
- */
- public PipedInputStream(PipedOutputStream source) throws IOException
- {
- connect(source);
- }
-
- /**
- * 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 this PipedInputStream or <code>source</code>
- * has been connected already.
- */
- public void connect(PipedOutputStream 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 receives a byte of input from the source PipedOutputStream.
- * If the internal circular buffer is full, this method blocks.
- *
- * @param byte_received The byte to write to this stream
- *
- * @exception IOException if error occurs
- * @specnote Weird. This method must be some sort of accident.
- */
- protected synchronized void receive(int b) throws IOException
- {
- read_buf[0] = (byte) (b & 0xff);
- receive (read_buf, 0, 1);
- }
-
- /**
- * This method is used by the connected <code>PipedOutputStream</code> to
- * write bytes into the buffer.
- *
- * @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
- * @specnote This code should be in PipedOutputStream.write, but we
- * put it here in order to support that bizarre recieve(int)
- * method.
- */
- synchronized void receive(byte[] 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 bytes 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 bytes until the pipe is filled, wrapping if necessary.
- 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 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 <code>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 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 r = read(read_buf, 0, 1);
-
- if (r == -1)
- return -1;
- else
- return read_buf[0];
- }
-
- /**
- * 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 <code>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 - ie close() was called on the
- * connected PipedOutputStream.
- * <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.
- *
- * @exception IOException If <code>close()/code> was called on this Piped
- * InputStream.
- */
- public synchronized int read(byte[] 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 bytes 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 outputstream that there is now space
- // to write.
- notifyAll();
- return total;
- }
- }
- }
-
- /**
- * 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
- {
- // The JDK 1.3 implementation does not appear to check for the closed or
- // unconnected stream conditions here.
-
- if (in < 0)
- return 0;
- else if (out < in)
- return in - out;
- else
- return (buffer.length - out) + in;
- }
-
- /**
- * 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;
- // Wake any thread which may be in receive() waiting to write data.
- notifyAll();
- }
-}
projects / msp430-gcc.git / blobdiff