FYI: Patch: java.io.BufferedInputStream

[Michael Koch <konqueror at gmx dot de>]

Hi list,


I just commited the attached patch to merge fixes done by Guilhem Lavaux 
in classpath.


Michael


2004-03-11  Guilhem Lavaux  <guilhem@kaffe.org>

	* java/io/BufferedInputStream.java (marktarget): New field for max
	mark limit.
	(CHUNKSIZE): New constant for incremental mark buffer allocation.
	(mark): Use new fields.
	(read): Likewise.
	(read(byte[],int,int)): Likewise.
	(skip): Likewise.
	(refill): Likewise.

Index: java/io/BufferedInputStream.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/BufferedInputStream.java,v
retrieving revision 1.6
diff -u -b -B -r1.6 BufferedInputStream.java
--- java/io/BufferedInputStream.java	22 Jan 2002 22:40:13 -0000	1.6
+++ java/io/BufferedInputStream.java	11 Mar 2004 14:41:04 -0000
@@ -103,6 +103,19 @@
   protected int marklimit = 0;
 
   /**
+   * This is the maximum size we have to allocate for the mark buffer.
+   * This number may be huge (Integer.MAX_VALUE). The class will continue
+   * to allocate new chunks (specified by <code>CHUNKSIZE</code>) until the
+   * the size specified by this field is achieved.
+   */
+  private int marktarget = 0;
+
+  /**
+   * This is the number of bytes to allocate to reach marktarget.
+   */
+  static final private int CHUNKSIZE = 1024;
+
+  /**
    * This method initializes a new <code>BufferedInputStream</code> that will
    * read from the specified subordinate stream with a default buffer size
    * of 2048 bytes
@@ -183,7 +196,9 @@
    */
   public synchronized void mark(int readlimit)
   {
-    marklimit = readlimit;
+    marktarget = marklimit = readlimit;
+    if (marklimit > CHUNKSIZE)
+	marklimit = CHUNKSIZE;
     markpos = pos;
   }
 
@@ -216,7 +231,7 @@
     if (pos >= count && !refill())
       return -1;	// EOF
 
-    if (markpos >= 0 && pos - markpos > marklimit)
+    if (markpos >= 0 && pos - markpos > marktarget)
       markpos = -1;
 
     return ((int) buf[pos++]) & 0xFF;
@@ -255,7 +270,7 @@
     System.arraycopy(buf, pos, b, off, remain);
     pos += remain;
 
-    if (markpos >= 0 && pos - markpos > marklimit)
+    if (markpos >= 0 && pos - markpos > marktarget)
       markpos = -1;
 
     return remain;
@@ -309,7 +324,7 @@
 	pos += numread;
 	n -= numread;
 
-        if (markpos >= 0 && pos - markpos > marklimit)
+        if (markpos >= 0 && pos - markpos > marktarget)
           markpos = -1;
       }
 
@@ -337,13 +352,16 @@
 	pos -= markpos;
 	markpos = 0;
       }
-    else if (marklimit >= buf.length)	// BTW, markpos == 0
+    else if (marktarget >= buf.length && marklimit < marktarget)	// BTW, markpos == 0
       {
 	// Need to grow the buffer now to have room for marklimit bytes.
 	// Note that the new buffer is one greater than marklimit.
 	// This is so that there will be one byte past marklimit to be read
 	// before having to call refill again, thus allowing marklimit to be
 	// invalidated.  That way refill doesn't have to check marklimit.
+	marklimit += CHUNKSIZE;
+	if (marklimit >= marktarget)
+	  marklimit = marktarget;
 	byte[] newbuf = new byte[marklimit + 1];
 	System.arraycopy(buf, 0, newbuf, 0, count);
 	buf = newbuf;