PatchSet 4077
Date: 2003/09/29 02:16:47
Author: dalibor
Branch: HEAD
Tag: (none)
Log:
Merged in java/util/zip/InflaterInputStream from GNU Classpath
Members:
ChangeLog:1.1672->1.1673
libraries/javalib/java/util/zip/InflaterInputStream.java:1.5->1.6
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.1672 kaffe/ChangeLog:1.1673
--- kaffe/ChangeLog:1.1672 Mon Sep 29 01:47:45 2003
+++ kaffe/ChangeLog Mon Sep 29 02:16:47 2003
@@ -1,5 +1,10 @@
2003-09-29 Dalibor Topic <[EMAIL PROTECTED]>
+ * libraries/javalib/java/util/zip/InflaterInputStream.java:
+ Replaced by implementation from GNU Classpath.
+
+2003-09-29 Dalibor Topic <[EMAIL PROTECTED]>
+
* libraries/javalib/java/util/zip/CheckedInputStream.java,
libraries/javalib/java/util/zip/CheckedOutputStream.java:
Replaced by implementation from GNU Classpath.
Index: kaffe/libraries/javalib/java/util/zip/InflaterInputStream.java
diff -u kaffe/libraries/javalib/java/util/zip/InflaterInputStream.java:1.5
kaffe/libraries/javalib/java/util/zip/InflaterInputStream.java:1.6
--- kaffe/libraries/javalib/java/util/zip/InflaterInputStream.java:1.5 Fri Aug 16
18:04:31 2002
+++ kaffe/libraries/javalib/java/util/zip/InflaterInputStream.java Mon Sep 29
02:16:49 2003
@@ -1,108 +1,237 @@
+/* java.util.zip.InflaterInputStream
+ Copyright (C) 2001, 2003 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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.util.zip;
import java.io.FilterInputStream;
-import java.io.IOException;
import java.io.InputStream;
+import java.io.IOException;
-/*
- * Java core library component.
+/**
+ * This filter stream is used to decompress data compressed in the "deflate"
+ * format. The "deflate" format is described in RFC 1951.
*
- * Copyright (c) 1997, 1998
- * Transvirtual Technologies, Inc. All rights reserved.
+ * This stream may form the basis for other decompression filters, such
+ * as the <code>GZIPInputStream</code>.
*
- * See the file "license.terms" for information on usage and redistribution
- * of this file.
+ * @author John Leuner
+ * @since 1.1
*/
-public class InflaterInputStream
- extends FilterInputStream
+public class InflaterInputStream extends FilterInputStream
{
- final private static int DEFAULT = 512;
- protected Inflater inf;
- protected byte[] buf;
- protected int len;
-
-public InflaterInputStream(InputStream in) {
- this(in, new Inflater(), DEFAULT);
-}
-
-public InflaterInputStream(InputStream in, Inflater inf) {
- this(in, inf, DEFAULT);
-}
-
-public InflaterInputStream(InputStream in, Inflater inf, int size) {
- super(in);
- if (in == null)
- throw new NullPointerException("in");
- if (inf == null)
- throw new NullPointerException("inf");
- this.inf = inf;
- if (size < 1)
- throw new IllegalArgumentException("size < 1");
- buf = new byte[size];
-}
-
-protected void fill() throws IOException {
- len = super.read(buf, 0, buf.length);
-}
-
-public int read() throws IOException {
- byte[] b = new byte[1];
- int r = read(b, 0, 1);
- if (r == -1) {
- return (-1);
- }
- else {
- return ((int)b[0]);
- }
-}
-
-public int read(byte b[], int off, int lenx) throws IOException {
- if (inf.finished()) {
- return (-1);
- }
- if (inf.needsInput()) {
- fill();
- if (len == -1) {
- return (-1);
- }
- inf.setInput(buf, 0, len);
- }
- try {
- /* we have to call inflate until
- * it is finished or needs more input
- */
- int inflated = 0;
- do {
- inflated += inf.inflate(b,
- off + inflated,
- lenx - inflated);
- }
- while (inflated < lenx && !inf.needsInput() && !inf.finished());
-
- /* recurse if only 0 bytes were inflated */
- if (inflated == 0 && lenx != 0) {
- return read(b, off, lenx);
- }
-
- return inflated;
- }
- catch (DataFormatException _) {
- throw new IOException("bad data format");
- }
-}
-
-public long skip(long n) throws IOException {
- // This is a terribly inefficient way to skip ...
- long cnt;
- byte[] b = new byte[1];
-
- for (cnt = 0; cnt < n; cnt++) {
- int r = read(b, 0, 1);
- if (r == -1) {
- break;
- }
- }
- return (cnt);
-}
-
+ /**
+ * Decompressor for this filter
+ */
+ protected Inflater inf;
+
+ /**
+ * Byte array used as a buffer
+ */
+ protected byte[] buf;
+
+ /**
+ * Size of buffer
+ */
+ protected int len;
+
+
+ /*
+ * We just use this if we are decoding one byte at a time with the read() call
+ */
+ private byte[] onebytebuffer = new byte[1];
+
+ /**
+ * Create an InflaterInputStream with the default decompresseor
+ * and a default buffer size.
+ *
+ * @param in the InputStream to read bytes from
+ */
+ public InflaterInputStream(InputStream in)
+ {
+ this(in, new Inflater(), 4096);
+ }
+
+ /**
+ * Create an InflaterInputStream with the specified decompresseor
+ * and a default buffer size.
+ *
+ * @param in the InputStream to read bytes from
+ * @param inf the decompressor used to decompress data read from in
+ */
+ public InflaterInputStream(InputStream in, Inflater inf)
+ {
+ this(in, inf, 4096);
+ }
+
+ /**
+ * Create an InflaterInputStream with the specified decompresseor
+ * and a specified buffer size.
+ *
+ * @param in the InputStream to read bytes from
+ * @param inf the decompressor used to decompress data read from in
+ * @param size size of the buffer to use
+ */
+ public InflaterInputStream(InputStream in, Inflater inf, int size)
+ {
+ super(in);
+ this.inf = inf;
+ this.len = 0;
+
+ if (size <= 0)
+ throw new IllegalArgumentException("size <= 0");
+ buf = new byte[size]; //Create the buffer
+
+ if (in == null)
+ throw new NullPointerException("InputStream null");
+ if (inf == null)
+ throw new NullPointerException("Inflater null");
+ }
+
+ /**
+ * Returns 0 once the end of the stream (EOF) has been reached.
+ * Otherwise returns 1.
+ */
+ public int available() throws IOException
+ {
+ return inf.finished() ? 0 : 1;
+ }
+
+ /**
+ * Closes the input stream
+ */
+ public synchronized void close() throws IOException
+ {
+ if (in != null)
+ in.close();
+ in = null;
+ }
+
+ /**
+ * Fills the buffer with more data to decompress.
+ */
+ protected void fill() throws IOException
+ {
+ if (in == null)
+ throw new ZipException ("InflaterInputStream is closed");
+
+ len = in.read(buf, 0, buf.length);
+
+ if (len < 0)
+ throw new ZipException("Deflated stream ends early.");
+
+ inf.setInput(buf, 0, len);
+ }
+
+ /**
+ * Reads one byte of decompressed data.
+ *
+ * The byte is in the lower 8 bits of the int.
+ */
+ public int read() throws IOException
+ {
+ int nread = read(onebytebuffer, 0, 1); //read one byte
+
+ if (nread > 0)
+ return onebytebuffer[0] & 0xff;
+
+ return -1;
+ }
+
+ /**
+ * Decompresses data into the byte array
+ *
+ * @param b the array to read and decompress data into
+ * @param off the offset indicating where the data should be placed
+ * @param len the number of bytes to decompress
+ */
+ public int read(byte[] b, int off, int len) throws IOException
+ {
+ if (len == 0) return 0;
+
+ for (;;)
+ {
+ int count;
+ try
+ {
+ count = inf.inflate(b, off, len);
+ }
+ catch (DataFormatException dfe)
+ {
+ throw new ZipException(dfe.getMessage());
+ }
+
+ if (count > 0)
+ return count;
+
+ if (inf.needsDictionary()
+ | inf.finished())
+ return -1;
+ else if (inf.needsInput())
+ fill();
+ else
+ throw new InternalError("Don't know what to do");
+ }
+ }
+
+ /**
+ * Skip specified number of bytes of uncompressed data
+ *
+ * @param n number of bytes to skip
+ */
+ public long skip(long n) throws IOException
+ {
+ if (n < 0)
+ throw new IllegalArgumentException();
+ int len = 2048;
+ if (n < len)
+ len = (int) n;
+ byte[] tmp = new byte[len];
+ return (long) read(tmp);
+ }
+
+ /**
+ * Since this stream tends to buffer large (unpredictable?) amounts
+ * of stuff, it causes problems to the mark/reset mechanism. Hence,
+ * it claims not to support mark.
+ *
+ * @return false
+ */
+ public boolean markSupported()
+ {
+ return false;
+ }
}
_______________________________________________
kaffe mailing list
[EMAIL PROTECTED]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
