Skip to content

R
riscv-gcc-1
Commit d3474943 by Tom Tromey Committed by Tom Tromey
Options

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.

From-SVN: r33300
parent 21caf590
Showing with 405 additions and 159 deletions
libjava/ChangeLog
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.
......
libjava/java/io/PipedOutputStream.java
// 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
* 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
{
/*************************************************************************/
/*
* Instance Variables
*/
/* 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 is the <code>PipedInputStream</code> to which this object
* is connected.
*/
private PipedInputStream snk;
/**
* This flag indicates whether or not this stream has ever been
* connected to an input stream
*/
private boolean ever_connected;
/**
* This flag indicates whether the <code>close</code> method has ever
* been called for this stream.
*/
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
*/
public class PipedOutputStream extends OutputStream
/**
* 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
{
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");
if (destination != null)
if (destination == dest)
return;
else
throw new IOException("pipe already connected");
destination = dest;
try
{
dest.connect(this);
}
catch (IOException ex)
{
destination = null;
throw ex;
}
}
public synchronized void flush () throws IOException
{
// There doesn't seem to be anything to do here.
// 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;
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
libjava/java/io/PipedWriter.java
// 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
* 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
{
/*************************************************************************/
/*
* Instance Variables
*/
/* 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 is the <code>PipedReader</code> to which this object
* is connected.
*/
private PipedReader snk;
/**
* This flag indicates whether or not this stream has ever been
* connected to an input stream
*/
private boolean ever_connected;
/**
* This flag indicates whether the <code>close</code> method has ever
* been called for this stream.
*/
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
*/
public class PipedWriter extends Writer
/**
* 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
{
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");
}
public PipedWriter ()
{
super ();
closed = false;
}
public PipedWriter (PipedReader sink) throws IOException
{
super ();
closed = false;
connect (sink);
}
public void write (char buffer[], int offset, int count) throws IOException
{
if (closed)
throw new IOException ("closed");
reader.receive(buffer, offset, count);
}
boolean isClosed ()
{
return closed;
}
// The associated reader.
private PipedReader reader;
private boolean closed;
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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment