Patch: java.io.Writer subclasses

[Tom Tromey <tromey at redhat dot com>]

I'm checking this in to the trunk and the branch.

This is related to PR 1913.  It fixes the subclasses of java.io.Writer
to have correct semantics regarding interaction with close().

I committed the relevant bits to Classpath.

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.

Tom

Index: java/io/BufferedWriter.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/BufferedWriter.java,v
retrieving revision 1.4
diff -u -r1.4 BufferedWriter.java
--- BufferedWriter.java	2000/05/19 23:35:34	1.4
+++ BufferedWriter.java	2001/02/20 18:59:25
@@ -1,12 +1,29 @@
-// 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;
 
@@ -67,8 +84,14 @@
    */
   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;
+      }
   }
 
   /**
@@ -79,8 +102,13 @@
    */
   public void flush () throws IOException
   {
-    localFlush ();
-    out.flush();
+    synchronized (lock)
+      {
+	if (buffer == null)
+	  throw new IOException ("Stream closed");
+	localFlush ();
+	out.flush();
+      }
   }
 
   /**
@@ -109,6 +137,8 @@
   {
     synchronized (lock)
       {
+	if (buffer == null)
+	  throw new IOException ("Stream closed");
 	buffer[count++] = (char) oneChar;
 	if (count == buffer.length)
 	  localFlush ();
@@ -135,6 +165,9 @@
 
     synchronized (lock)
       {
+	if (buffer == null)
+	  throw new IOException ("Stream closed");
+
 	// Bypass buffering if there is too much incoming data.
 	if (count + len > buffer.length)
 	  {
@@ -171,6 +204,9 @@
 
     synchronized (lock)
       {
+	if (buffer == null)
+	  throw new IOException ("Stream closed");
+
 	if (count + len > buffer.length)
 	  {
 	    localFlush ();
Index: java/io/CharArrayWriter.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/CharArrayWriter.java,v
retrieving revision 1.3
diff -u -r1.3 CharArrayWriter.java
--- CharArrayWriter.java	2000/03/07 19:55:26	1.3
+++ CharArrayWriter.java	2001/02/20 18:59:25
@@ -1,6 +1,6 @@
 // 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.
 
@@ -35,18 +35,27 @@
 
   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 ()
@@ -56,29 +65,41 @@
 
   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);
@@ -86,10 +107,13 @@
       }
   }
 
-  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);
@@ -99,7 +123,10 @@
 
   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)
@@ -119,4 +146,6 @@
   protected char[] buf;
   // Number of valid characters in buffer.
   protected int count;
+  // True if stream is closed.
+  private boolean closed;
 }
Index: java/io/OutputStreamWriter.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/OutputStreamWriter.java,v
retrieving revision 1.9
diff -u -r1.9 OutputStreamWriter.java
--- OutputStreamWriter.java	2001/02/09 04:01:59	1.9
+++ OutputStreamWriter.java	2001/02/20 18:59:26
@@ -86,6 +86,9 @@
   {
     synchronized (lock)
       {
+	if (out == null)
+	  throw new IOException("Stream closed");
+
 	if (wcount > 0)
 	  {
 	    writeChars(work, 0, wcount);
@@ -100,9 +103,6 @@
   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.
@@ -127,6 +127,9 @@
   {
     synchronized (lock)
       {
+	if (out == null)
+	  throw new IOException("Stream closed");
+
 	if (work == null)
 	  work = new char[100];
 	int wlength = work.length;
@@ -155,6 +158,9 @@
   {
     synchronized (lock)
       {
+	if (out == null)
+	  throw new IOException("Stream closed");
+
 	if (work == null)
 	  work = new char[100];
 	if (wcount >= work.length)
Index: java/io/PipedWriter.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/PipedWriter.java,v
retrieving revision 1.5
diff -u -r1.5 PipedWriter.java
--- PipedWriter.java	2001/01/05 08:23:51	1.5
+++ PipedWriter.java	2001/02/20 18:59:26
@@ -142,8 +142,10 @@
     *           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");
   }
   
   /**