From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/classpath/java/io/PipedReader.java | 364 +++++++++++++++++++++++++++++ 1 file changed, 364 insertions(+) create mode 100644 libjava/classpath/java/io/PipedReader.java (limited to 'libjava/classpath/java/io/PipedReader.java') diff --git a/libjava/classpath/java/io/PipedReader.java b/libjava/classpath/java/io/PipedReader.java new file mode 100644 index 000000000..4f449ffce --- /dev/null +++ b/libjava/classpath/java/io/PipedReader.java @@ -0,0 +1,364 @@ +/* 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. + +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; + +// 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. + +/** + * An input stream that reads characters from a piped writer to which it is + * connected. + *

+ * Data is read and written to an internal buffer. It is highly recommended + * that the PipedReader and connected PipedWriter + * be part of different threads. If they are not, there is a possibility + * that 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 PipedReader extends Reader +{ + /** 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 + * PipedWriter will be written. If this variable is + * equal to out, 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 PipedReader that is not connected to a + * PipedWriter. It must be connected before chars can + * be read from this stream. + */ + public PipedReader() + { + } + + /** + * This constructor creates a new PipedReader and connects + * it to the passed in PipedWriter. The stream is then + * ready for reading. + * + * @param source The PipedWriter to connect this stream to + * + * @exception IOException If source is already connected. + */ + public PipedReader(PipedWriter source) throws IOException + { + connect(source); + } + + /** + * This method connects this stream to the passed in + * PipedWriter. + * This stream is then ready for reading. If this stream is already + * connected or has been previously closed, then an exception is thrown + * + * @param source The PipedWriter to connect this stream to + * + * @exception IOException If this PipedReader or source + * 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 PipedWriter 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. + */ + void receive(char[] buf, int offset, int len) + throws IOException + { + synchronized (lock) + { + 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. + lock.notifyAll(); + lock.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 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. + lock.notifyAll(); + } + } + + /** + * This method reads chars from the stream into a caller supplied buffer. + * It starts storing chars at position offset into the + * buffer and + * reads a maximum of len chars. Note that this method + * can actually + * read fewer than len 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. + *

+ * This method will block if no char is available to be 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); + return r != -1 ? read_buf[0] : -1; + } + + /** + * This method reads characters from the stream into a caller supplied + * buffer. It starts storing chars at position offset into + * the buffer and reads a maximum of len chars. Note that + * this method can actually read fewer than len 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. + *

+ * 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 close() was called on this Piped + * Reader. + */ + public int read(char[] buf, int offset, int len) + throws IOException + { + synchronized (lock) + { + if (source == null) + throw new IOException ("Not connected"); + if (closed) + throw new IOException ("Pipe closed"); + + // Don't block if nothing was requested. + if (len == 0) + return 0; + + // If the buffer is empty, wait until there is something in the pipe + // to read. + try + { + while (in < 0) + { + if (source.closed) + return -1; + lock.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. + lock.notifyAll(); + return total; + } + } + } + } + + public boolean ready() throws IOException + { + // The JDK 1.3 implementation does not appear to check for the closed or + // unconnected stream conditions here. However, checking for a + // closed stream is explicitly required by the JDK 1.2 and 1.3 + // documentation (for Reader.close()), so we do it. + + synchronized (lock) + { + if (closed) + throw new IOException("Pipe closed"); + + 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; + // Wake any thread which may be in receive() waiting to write data. + lock.notifyAll(); + } + } +} -- cgit v1.2.3