closed.
* java/io/OutputStreamWriter.java (write): Throw exception if
stream closed.
(writeChars): Don't throw exception if stream closed.
* java/io/CharArrayWriter.java (closed): New field.
(close): Set it.
(flush): Throw exception if stream closed.
(reset): Synchronize on correct lock. Allow stream to be
reopened.
(toCharArray, toString, writeTo): Synchronize.
(write): Throwe exception if stream closed.
* java/io/BufferedWriter.java (close): Clear `buffer'.
(flush): Throw IOException if stream is closed.
(write): Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@39927
138bc75d-0d04-0410-961f-
82ee72b054a4
+2001-02-20 Tom Tromey <tromey@redhat.com>
+
+ * java/io/PipedWriter.java (flush): Throw exception if stream
+ closed.
+ * java/io/OutputStreamWriter.java (write): Throw exception if
+ stream closed.
+ (writeChars): Don't throw exception if stream closed.
+ * java/io/CharArrayWriter.java (closed): New field.
+ (close): Set it.
+ (flush): Throw exception if stream closed.
+ (reset): Synchronize on correct lock. Allow stream to be
+ reopened.
+ (toCharArray, toString, writeTo): Synchronize.
+ (write): Throwe exception if stream closed.
+ * java/io/BufferedWriter.java (close): Clear `buffer'.
+ (flush): Throw IOException if stream is closed.
+ (write): Likewise.
+
2001-02-16 Tom Tromey <tromey@cygnus.com>
* java/lang/ThreadGroup.java (activeCount): Only include threads
-// BufferedWriter.java - Filtered character output stream.
+/* BufferedWriter.java -- Buffer output into large blocks before writing
+ Copyright (C) 1998, 1999, 2000 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;
*/
public void close () throws IOException
{
- localFlush ();
- out.close();
+ synchronized (lock)
+ {
+ // It is safe to call localFlush even if the stream is already
+ // closed.
+ localFlush ();
+ out.close();
+ buffer = null;
+ }
}
/**
*/
public void flush () throws IOException
{
- localFlush ();
- out.flush();
+ synchronized (lock)
+ {
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+ localFlush ();
+ out.flush();
+ }
}
/**
{
synchronized (lock)
{
+ if (buffer == null)
+ throw new IOException ("Stream closed");
buffer[count++] = (char) oneChar;
if (count == buffer.length)
localFlush ();
synchronized (lock)
{
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+
// Bypass buffering if there is too much incoming data.
if (count + len > buffer.length)
{
synchronized (lock)
{
+ if (buffer == null)
+ throw new IOException ("Stream closed");
+
if (count + len > buffer.length)
{
localFlush ();
// CharArrayWriter.java - Character array output stream.
-/* Copyright (C) 1998, 1999 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2001 Free Software Foundation
This file is part of libgcj.
public void close ()
{
- // JCL says this does nothing. This seems to violate the Writer
- // contract, in that other methods should still throw and
- // IOException after a close. Still, we just follow JCL.
+ closed = true;
}
- public void flush ()
+ public void flush () throws IOException
{
+ synchronized (lock)
+ {
+ if (closed)
+ throw new IOException ("Stream closed");
+ }
}
- public synchronized void reset ()
+ public void reset ()
{
- count = 0;
+ synchronized (lock)
+ {
+ count = 0;
+ // Allow this to reopen the stream.
+ // FIXME - what does the JDK do?
+ closed = false;
+ }
}
public int size ()
public char[] toCharArray ()
{
- char[] nc = new char[count];
- System.arraycopy(buf, 0, nc, 0, count);
- return nc;
+ synchronized (lock)
+ {
+ char[] nc = new char[count];
+ System.arraycopy(buf, 0, nc, 0, count);
+ return nc;
+ }
}
public String toString ()
{
- return new String (buf, 0, count);
+ synchronized (lock)
+ {
+ return new String (buf, 0, count);
+ }
}
- public void write (int oneChar)
+ public void write (int oneChar) throws IOException
{
synchronized (lock)
{
+ if (closed)
+ throw new IOException ("Stream closed");
+
resize (1);
buf[count++] = (char) oneChar;
}
}
- public void write (char[] buffer, int offset, int len)
+ public void write (char[] buffer, int offset, int len) throws IOException
{
synchronized (lock)
{
+ if (closed)
+ throw new IOException ("Stream closed");
+
if (len >= 0)
resize (len);
System.arraycopy(buffer, offset, buf, count, len);
}
}
- public void write (String str, int offset, int len)
+ public void write (String str, int offset, int len) throws IOException
{
synchronized (lock)
{
+ if (closed)
+ throw new IOException ("Stream closed");
+
if (len >= 0)
resize (len);
str.getChars(offset, offset + len, buf, count);
public void writeTo (Writer out) throws IOException
{
- out.write(buf, 0, count);
+ synchronized (lock)
+ {
+ out.write(buf, 0, count);
+ }
}
private final void resize (int len)
protected char[] buf;
// Number of valid characters in buffer.
protected int count;
+ // True if stream is closed.
+ private boolean closed;
}
{
synchronized (lock)
{
+ if (out == null)
+ throw new IOException("Stream closed");
+
if (wcount > 0)
{
writeChars(work, 0, wcount);
private void writeChars(char[] buf, int offset, int count)
throws IOException
{
- if (out == null)
- throw new IOException("Stream closed");
-
while (count > 0)
{
// We must flush if out.count == out.buf.length.
{
synchronized (lock)
{
+ if (out == null)
+ throw new IOException("Stream closed");
+
if (work == null)
work = new char[100];
int wlength = work.length;
{
synchronized (lock)
{
+ if (out == null)
+ throw new IOException("Stream closed");
+
if (work == null)
work = new char[100];
if (wcount >= work.length)
* had read all available data. Thats not the case - this method
* appears to be a no-op?
*/
- public void flush()
+ public void flush() throws IOException
{
+ if (closed)
+ throw new IOException ("Pipe closed");
}
/**
projects / platform / upstream / linaro-gcc.git / commitdiff