rubysl-zlib 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c8834ce05136d4bccc980b8340f08ffdc55b2b8
-  data.tar.gz: 89e1a54194e94a79c962cf8e51d97375cc09fcce
+  metadata.gz: 1076e7a2ba523e3a8345ea34fe039b2184052466
+  data.tar.gz: c6b070cd9a773dd02db9ef613f373fc800abeae8
 SHA512:
-  metadata.gz: 89d136000290cdc485aba19fa7608df7ca633502d397c53bf5f1d21dfd4958e0d5cb89d40a746d72b0b9ce45673d866c33c993d44754f7245bc66dbc0c4ad222
-  data.tar.gz: 9cfc9b259bc9d8ad304457cda99e27c628dc78bf79ceb7268828c6f6adb3741f2f5c97b354dff6d7d755a0929808b6615684184f5e28b0524a55f70518fb17b9
+  metadata.gz: 415ef09bc699e6de21edae923dd75f8384e96b2851d428071fc454cab229224e0e7e7140d99175a69ee21524eff8f61dc63133054ee3274894a38c1396337d29
+  data.tar.gz: 0d111deffcf2c356940db2e85ca7cb230febafb2efa210b074a7340c8b9c6c6173160f1d15d84c0510782552b391bedc700d5e2c46a710ab955a0573f2c5de52

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
+before_install:
+  - rvm use $RVM --install --binary --fuzzy
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
 env:
-  - RUBYLIB=lib
-script: bundle exec mspec
-rvm:
-  - 1.9.3
-  - rbx-nightly-19mode
+  - RVM=rbx-nightly-d21 RUBYLIB=lib
+script: bundle exec mspec spec

data/ext/rubysl/zlib/extconf.rb

@@ -1,7 +1,7 @@
 #
 # extconf.rb
 #
-# $Id: extconf.rb 26353 2010-01-19 05:14:29Z usa $
+# $Id: extconf.rb 37527 2012-11-06 18:50:53Z luislavena $
 #
 
 require 'mkmf'
@@ -10,12 +10,12 @@ require 'rbconfig'
 dir_config 'zlib'
 
 
-if %w'z libz zlib1 zlib zdll'.find {|z| have_library(z, 'deflateReset')} and
+if %w'z libz zlib1 zlib zdll zlibwapi'.find {|z| have_library(z, 'deflateReset')} and
     have_header('zlib.h') then
 
   defines = []
 
-  message 'checking for kind of operating system... '
+  Logging::message 'checking for kind of operating system... '
   os_code = with_config('os-code') ||
     case RUBY_PLATFORM.split('-',2)[1]
     when 'amigaos' then
@@ -48,14 +48,11 @@ if %w'z libz zlib1 zlib zdll'.find {|z| have_library(z, 'deflateReset')} and
     'OS_UNKNOWN' => 'Unknown',
   }
   unless OS_NAMES.key? os_code then
-    puts "invalid OS_CODE `#{os_code}'"
-    exit
+    raise "invalid OS_CODE `#{os_code}'"
   end
-  message "#{OS_NAMES[os_code]}\n"
+  Logging::message "#{OS_NAMES[os_code]}\n"
   defines << "OS_CODE=#{os_code}"
 
-  $CFLAGS += " -Wno-pointer-sign"
-
   $defs.concat(defines.collect{|d|' -D'+d})
 
   have_func('crc32_combine', 'zlib.h')

data/ext/rubysl/zlib/zlib.c

@@ -3,7 +3,7 @@
  *
  *   Copyright (C) UENO Katsuhiro 2000-2003
  *
- * $Id: zlib.c 34544 2012-02-10 18:37:45Z naruse $
+ * $Id: zlib.c 42720 2013-08-28 20:36:21Z drbrain $
  */
 
 #define RSTRING_NOT_MODIFIED 1
@@ -12,6 +12,7 @@
 #include <zlib.h>
 #include <time.h>
 #include <ruby/io.h>
+#include <ruby/thread.h>
 
 #ifdef HAVE_VALGRIND_MEMCHECK_H
 # include <valgrind/memcheck.h>
@@ -22,8 +23,8 @@
 #  define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
 # endif
 #else
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) /* empty */
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) /* empty */
+# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
+# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
 #endif
 
 #define RUBY_ZLIB_VERSION  "0.6.0"
@@ -58,6 +59,8 @@ max_uint(long n)
 
 #define sizeof(x) ((int)sizeof(x))
 
+static ID id_dictionaries;
+
 /*--------- Prototypes --------*/
 
 static NORETURN(void raise_zlib_error(int, const char*));
@@ -72,6 +75,7 @@ static void finalizer_warn(const char*);
 
 struct zstream;
 struct zstream_funcs;
+struct zstream_run_args;
 static void zstream_init(struct zstream*, const struct zstream_funcs*);
 static void zstream_expand_buffer(struct zstream*);
 static void zstream_expand_buffer_into(struct zstream*, unsigned long);
@@ -224,9 +228,50 @@ static VALUE rb_gzreader_readlines(int, VALUE*, VALUE);
 /*
  * Document-module: Zlib
  *
- * == Overview
+ * This module provides access to the {zlib library}[http://zlib.net]. Zlib is
+ * designed to be a portable, free, general-purpose, legally unencumbered --
+ * that is, not covered by any patents -- lossless data-compression library
+ * for use on virtually any computer hardware and operating system.
+ *
+ * The zlib compression library provides in-memory compression and
+ * decompression functions, including integrity checks of the uncompressed
+ * data.
+ *
+ * The zlib compressed data format is described in RFC 1950, which is a
+ * wrapper around a deflate stream which is described in RFC 1951.
+ *
+ * The library also supports reading and writing files in gzip (.gz) format
+ * with an interface similar to that of IO. The gzip format is described in
+ * RFC 1952 which is also a wrapper around a deflate stream.
+ *
+ * The zlib format was designed to be compact and fast for use in memory and on
+ * communications channels. The gzip format was designed for single-file
+ * compression on file systems, has a larger header than zlib to maintain
+ * directory information, and uses a different, slower check method than zlib.
+ *
+ * See your system's zlib.h for further information about zlib
+ *
+ * == Sample usage
+ *
+ * Using the wrapper to compress strings with default parameters is quite
+ * simple:
+ *
+ *   require "zlib"
+ *
+ *   data_to_compress = File.read("don_quixote.txt")
+ *
+ *   puts "Input size: #{data_to_compress.size}"
+ *   #=> Input size: 2347740
+ *
+ *   data_compressed = Zlib::Deflate.deflate(data_to_compress)
+ *
+ *   puts "Compressed size: #{data_compressed.size}"
+ *   #=> Compressed size: 887238
+ *
+ *   uncompressed_data = Zlib::Inflate.inflate(data_compressed)
  *
- * Access to the zlib library.
+ *   puts "Uncompressed data is: #{uncompressed_data}"
+ *   #=> Uncompressed data is: The Project Gutenberg EBook of Don Quixote...
  *
  * == Class tree
  *
@@ -251,8 +296,6 @@ static VALUE rb_gzreader_readlines(int, VALUE*, VALUE);
  *   - Zlib::GzipFile::CRCError
  *   - Zlib::GzipFile::NoFooter
  *
- * see also zlib.h
- *
  */
 void Init_zlib(void);
 
@@ -267,39 +310,39 @@ raise_zlib_error(int err, const char *msg)
     VALUE exc;
 
     if (!msg) {
-        msg = zError(err);
+	msg = zError(err);
     }
 
     switch(err) {
       case Z_STREAM_END:
-        exc = rb_exc_new2(cStreamEnd, msg);
-        break;
+	exc = rb_exc_new2(cStreamEnd, msg);
+	break;
       case Z_NEED_DICT:
-        exc = rb_exc_new2(cNeedDict, msg);
-        break;
+	exc = rb_exc_new2(cNeedDict, msg);
+	break;
       case Z_STREAM_ERROR:
-        exc = rb_exc_new2(cStreamError, msg);
-        break;
+	exc = rb_exc_new2(cStreamError, msg);
+	break;
       case Z_DATA_ERROR:
-        exc = rb_exc_new2(cDataError, msg);
-        break;
+	exc = rb_exc_new2(cDataError, msg);
+	break;
       case Z_BUF_ERROR:
-        exc = rb_exc_new2(cBufError, msg);
-        break;
+	exc = rb_exc_new2(cBufError, msg);
+	break;
       case Z_VERSION_ERROR:
-        exc = rb_exc_new2(cVersionError, msg);
-        break;
+	exc = rb_exc_new2(cVersionError, msg);
+	break;
       case Z_MEM_ERROR:
-        exc = rb_exc_new2(cMemError, msg);
-        break;
+	exc = rb_exc_new2(cMemError, msg);
+	break;
       case Z_ERRNO:
-        rb_sys_fail(msg);
-        /* no return */
+	rb_sys_fail(msg);
+	/* no return */
       default:
       {
-          char buf[BUFSIZ];
-          snprintf(buf, BUFSIZ, "unknown zlib error %d: %s", err, msg);
-          exc = rb_exc_new2(cZError, buf);
+	  char buf[BUFSIZ];
+	  snprintf(buf, BUFSIZ, "unknown zlib error %d: %s", err, msg);
+	  exc = rb_exc_new2(cZError, buf);
       }
     }
 
@@ -338,11 +381,11 @@ static uLong
 checksum_long(uLong (*func)(uLong, const Bytef*, uInt), uLong sum, const Bytef *ptr, long len)
 {
     if (len > UINT_MAX) {
-        do {
-            sum = func(sum, ptr, UINT_MAX);
-            ptr += UINT_MAX;
-            len -= UINT_MAX;
-        } while (len >= UINT_MAX);
+	do {
+	    sum = func(sum, ptr, UINT_MAX);
+	    ptr += UINT_MAX;
+	    len -= UINT_MAX;
+	} while (len >= UINT_MAX);
     }
     if (len > 0) sum = func(sum, ptr, (uInt)len);
     return sum;
@@ -363,21 +406,21 @@ do_checksum(argc, argv, func)
     rb_scan_args(argc, argv, "02", &str, &vsum);
 
     if (!NIL_P(vsum)) {
-        sum = NUM2ULONG(vsum);
+	sum = NUM2ULONG(vsum);
     }
     else if (NIL_P(str)) {
-        sum = 0;
+	sum = 0;
     }
     else {
-        sum = func(0, Z_NULL, 0);
+	sum = func(0, Z_NULL, 0);
     }
 
     if (NIL_P(str)) {
-        sum = func(sum, Z_NULL, 0);
+	sum = func(sum, Z_NULL, 0);
     }
     else {
-        StringValue(str);
-        sum = checksum_long(func, sum, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
+	StringValue(str);
+	sum = checksum_long(func, sum, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
     }
     return rb_uint2inum(sum);
 }
@@ -414,7 +457,7 @@ static VALUE
 rb_zlib_adler32_combine(VALUE klass, VALUE adler1, VALUE adler2, VALUE len2)
 {
   return ULONG2NUM(
-        adler32_combine(NUM2ULONG(adler1), NUM2ULONG(adler2), NUM2LONG(len2)));
+	adler32_combine(NUM2ULONG(adler1), NUM2ULONG(adler2), NUM2LONG(len2)));
 }
 #else
 #define rb_zlib_adler32_combine rb_f_notimplement
@@ -452,7 +495,7 @@ static VALUE
 rb_zlib_crc32_combine(VALUE klass, VALUE crc1, VALUE crc2, VALUE len2)
 {
   return ULONG2NUM(
-        crc32_combine(NUM2ULONG(crc1), NUM2ULONG(crc2), NUM2LONG(len2)));
+	crc32_combine(NUM2ULONG(crc1), NUM2ULONG(crc2), NUM2LONG(len2)));
 }
 #else
 #define rb_zlib_crc32_combine rb_f_notimplement
@@ -478,7 +521,7 @@ rb_zlib_crc_table(VALUE obj)
     dst = rb_ary_new2(256);
 
     for (i = 0; i < 256; i++) {
-        rb_ary_push(dst, rb_uint2inum(crctbl[i]));
+	rb_ary_push(dst, rb_uint2inum(crctbl[i]));
     }
     return dst;
 }
@@ -494,9 +537,9 @@ struct zstream {
     VALUE input;
     z_stream stream;
     const struct zstream_funcs {
-        int (*reset)(z_streamp);
-        int (*end)(z_streamp);
-        int (*run)(z_streamp, int);
+	int (*reset)(z_streamp);
+	int (*end)(z_streamp);
+	int (*run)(z_streamp, int);
     } *func;
 };
 
@@ -504,16 +547,22 @@ struct zstream {
 #define ZSTREAM_FLAG_IN_STREAM  0x2
 #define ZSTREAM_FLAG_FINISHED   0x4
 #define ZSTREAM_FLAG_CLOSING    0x8
-#define ZSTREAM_FLAG_UNUSED     0x10
+#define ZSTREAM_FLAG_GZFILE     0x10 /* disallows yield from expand_buffer for
+                                        gzip*/
+#define ZSTREAM_FLAG_UNUSED     0x20
 
 #define ZSTREAM_READY(z)       ((z)->flags |= ZSTREAM_FLAG_READY)
 #define ZSTREAM_IS_READY(z)    ((z)->flags & ZSTREAM_FLAG_READY)
 #define ZSTREAM_IS_FINISHED(z) ((z)->flags & ZSTREAM_FLAG_FINISHED)
 #define ZSTREAM_IS_CLOSING(z)  ((z)->flags & ZSTREAM_FLAG_CLOSING)
+#define ZSTREAM_IS_GZFILE(z)   ((z)->flags & ZSTREAM_FLAG_GZFILE)
+
+#define ZSTREAM_EXPAND_BUFFER_OK          0
 
 /* I think that more better value should be found,
    but I gave up finding it. B) */
 #define ZSTREAM_INITIAL_BUFSIZE       1024
+/* Allow a quick return when the thread is interrupted */
 #define ZSTREAM_AVAIL_OUT_STEP_MAX   16384
 #define ZSTREAM_AVAIL_OUT_STEP_MIN    2048
 
@@ -525,6 +574,13 @@ static const struct zstream_funcs inflate_funcs = {
     inflateReset, inflateEnd, inflate,
 };
 
+struct zstream_run_args {
+    struct zstream * z;
+    int flush;         /* stream flush value for inflate() or deflate() */
+    int interrupt;     /* stop processing the stream and return to ruby */
+    int jump_state;    /* for buffer expansion block break or exception */
+    int stream_output; /* for streaming zlib processing */
+};
 
 static voidpf
 zlib_mem_alloc(voidpf opaque, uInt items, uInt size)
@@ -534,7 +590,7 @@ zlib_mem_alloc(voidpf opaque, uInt items, uInt size)
        deflate is performing a conditional jump that depends on an
        uninitialized value.  Isn't that a bug?
        http://www.zlib.net/zlib_faq.html#faq36 */
-    VALGRIND_MAKE_MEM_DEFINED(p, items * size);
+    (void)VALGRIND_MAKE_MEM_DEFINED(p, items * size);
     return p;
 }
 
@@ -568,75 +624,106 @@ zstream_init(struct zstream *z, const struct zstream_funcs *func)
 static void
 zstream_expand_buffer(struct zstream *z)
 {
-    long inc;
-
     if (NIL_P(z->buf)) {
-            /* I uses rb_str_new here not rb_str_buf_new because
-               rb_str_buf_new makes a zero-length string. */
-        z->buf = rb_str_new(0, ZSTREAM_INITIAL_BUFSIZE);
-        z->buf_filled = 0;
-        z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
-        z->stream.avail_out = ZSTREAM_INITIAL_BUFSIZE;
-        return;
+	zstream_expand_buffer_into(z, ZSTREAM_INITIAL_BUFSIZE);
+	return;
     }
 
-    if (RSTRING_LEN(z->buf) - z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
-        /* to keep other threads from freezing */
-        z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;
+    if (!ZSTREAM_IS_GZFILE(z) && rb_block_given_p()) {
+	if (z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
+	    int state = 0;
+	    VALUE self = (VALUE)z->stream.opaque;
+
+	    rb_str_resize(z->buf, z->buf_filled);
+	    rb_obj_reveal(z->buf, rb_cString);
+	    OBJ_INFECT(z->buf, self);
+
+	    rb_protect(rb_yield, z->buf, &state);
+
+	    z->buf = Qnil;
+	    zstream_expand_buffer_into(z, ZSTREAM_AVAIL_OUT_STEP_MAX);
+
+	    if (state)
+		rb_jump_tag(state);
+
+	    return;
+	}
+	else {
+	    zstream_expand_buffer_into(z,
+		    ZSTREAM_AVAIL_OUT_STEP_MAX - z->buf_filled);
+	}
     }
     else {
-        inc = z->buf_filled / 2;
-        if (inc < ZSTREAM_AVAIL_OUT_STEP_MIN) {
-            inc = ZSTREAM_AVAIL_OUT_STEP_MIN;
-        }
-        rb_str_resize(z->buf, z->buf_filled + inc);
-        z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?
-            (int)inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
+	if (RSTRING_LEN(z->buf) - z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
+	    z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;
+	}
+	else {
+	    long inc = z->buf_filled / 2;
+	    if (inc < ZSTREAM_AVAIL_OUT_STEP_MIN) {
+		inc = ZSTREAM_AVAIL_OUT_STEP_MIN;
+	    }
+	    rb_str_resize(z->buf, z->buf_filled + inc);
+	    z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?
+		(int)inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
+	}
+	z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
     }
-    z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
 }
 
 static void
 zstream_expand_buffer_into(struct zstream *z, unsigned long size)
 {
     if (NIL_P(z->buf)) {
-        /* I uses rb_str_new here not rb_str_buf_new because
-           rb_str_buf_new makes a zero-length string. */
-        z->buf = rb_str_new(0, size);
-        z->buf_filled = 0;
-        z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
-        z->stream.avail_out = MAX_UINT(size);
+	/* I uses rb_str_new here not rb_str_buf_new because
+	   rb_str_buf_new makes a zero-length string. */
+	z->buf = rb_str_new(0, size);
+	z->buf_filled = 0;
+	z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
+	z->stream.avail_out = MAX_UINT(size);
+	rb_obj_hide(z->buf);
     }
     else if (z->stream.avail_out != size) {
-        rb_str_resize(z->buf, z->buf_filled + size);
-        z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
-        z->stream.avail_out = MAX_UINT(size);
+	rb_str_resize(z->buf, z->buf_filled + size);
+	z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
+	z->stream.avail_out = MAX_UINT(size);
     }
 }
 
+static void *
+zstream_expand_buffer_protect(void *ptr)
+{
+    struct zstream *z = (struct zstream *)ptr;
+    int state = 0;
+
+    rb_protect((VALUE (*)(VALUE))zstream_expand_buffer, (VALUE)z, &state);
+
+    return (void *)(VALUE)state;
+}
+
 static void
 zstream_append_buffer(struct zstream *z, const Bytef *src, long len)
 {
     if (NIL_P(z->buf)) {
-        z->buf = rb_str_buf_new(len);
-        rb_str_buf_cat(z->buf, (const char*)src, len);
-        z->buf_filled = len;
-        z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
-        z->stream.avail_out = 0;
-        return;
+	z->buf = rb_str_buf_new(len);
+	rb_str_buf_cat(z->buf, (const char*)src, len);
+	z->buf_filled = len;
+	z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
+	z->stream.avail_out = 0;
+	rb_obj_hide(z->buf);
+	return;
     }
 
     if (RSTRING_LEN(z->buf) < z->buf_filled + len) {
-        rb_str_resize(z->buf, z->buf_filled + len);
-        z->stream.avail_out = 0;
+	rb_str_resize(z->buf, z->buf_filled + len);
+	z->stream.avail_out = 0;
     }
     else {
-        if (z->stream.avail_out >= (uInt)len) {
-            z->stream.avail_out -= (uInt)len;
-        }
-        else {
-            z->stream.avail_out = 0;
-        }
+	if (z->stream.avail_out >= (uInt)len) {
+	    z->stream.avail_out -= (uInt)len;
+	}
+	else {
+	    z->stream.avail_out = 0;
+	}
     }
     memcpy(RSTRING_PTR(z->buf) + z->buf_filled, src, len);
     z->buf_filled += len;
@@ -649,20 +736,36 @@ zstream_append_buffer(struct zstream *z, const Bytef *src, long len)
 static VALUE
 zstream_detach_buffer(struct zstream *z)
 {
-    VALUE dst;
+    VALUE dst, self = (VALUE)z->stream.opaque;
+
+    if (!ZSTREAM_IS_FINISHED(z) && !ZSTREAM_IS_GZFILE(z) &&
+	    rb_block_given_p()) {
+	/* prevent tiny yields mid-stream, save for next
+	 * zstream_expand_buffer() or stream end */
+	return Qnil;
+    }
 
     if (NIL_P(z->buf)) {
-        dst = rb_str_new(0, 0);
+	dst = rb_str_new(0, 0);
     }
     else {
-        dst = z->buf;
-        rb_str_resize(dst, z->buf_filled);
+	dst = z->buf;
+	rb_str_resize(dst, z->buf_filled);
+	rb_obj_reveal(dst, rb_cString);
     }
 
+    OBJ_INFECT(dst, self);
+
     z->buf = Qnil;
     z->buf_filled = 0;
     z->stream.next_out = 0;
     z->stream.avail_out = 0;
+
+    if (!ZSTREAM_IS_GZFILE(z) && rb_block_given_p()) {
+	rb_yield(dst);
+	dst = Qnil;
+    }
+
     return dst;
 }
 
@@ -673,17 +776,18 @@ zstream_shift_buffer(struct zstream *z, long len)
     long buflen;
 
     if (z->buf_filled <= len) {
-        return zstream_detach_buffer(z);
+	return zstream_detach_buffer(z);
     }
 
     dst = rb_str_subseq(z->buf, 0, len);
+    rb_obj_reveal(dst, rb_cString);
     z->buf_filled -= len;
     memmove(RSTRING_PTR(z->buf), RSTRING_PTR(z->buf) + len,
-            z->buf_filled);
+	    z->buf_filled);
     z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
     buflen = RSTRING_LEN(z->buf) - z->buf_filled;
     if (buflen > ZSTREAM_AVAIL_OUT_STEP_MAX) {
-        buflen = ZSTREAM_AVAIL_OUT_STEP_MAX;
+	buflen = ZSTREAM_AVAIL_OUT_STEP_MAX;
     }
     z->stream.avail_out = (uInt)buflen;
 
@@ -694,16 +798,16 @@ static void
 zstream_buffer_ungets(struct zstream *z, const Bytef *b, unsigned long len)
 {
     if (NIL_P(z->buf) || RSTRING_LEN(z->buf) - z->buf_filled == 0) {
-        zstream_expand_buffer_into(z, len);
+	zstream_expand_buffer_into(z, len);
     }
 
     memmove(RSTRING_PTR(z->buf) + len, RSTRING_PTR(z->buf), z->buf_filled);
     memmove(RSTRING_PTR(z->buf), b, len);
     z->buf_filled+=len;
     if (z->stream.avail_out > 0) {
-        if (len > z->stream.avail_out) len = z->stream.avail_out;
-        z->stream.next_out+=len;
-        z->stream.avail_out-=(uInt)len;
+	if (len > z->stream.avail_out) len = z->stream.avail_out;
+	z->stream.next_out+=len;
+	z->stream.avail_out-=(uInt)len;
     }
 }
 
@@ -711,15 +815,15 @@ static void
 zstream_buffer_ungetbyte(struct zstream *z, int c)
 {
     if (NIL_P(z->buf) || RSTRING_LEN(z->buf) - z->buf_filled == 0) {
-        zstream_expand_buffer(z);
+	zstream_expand_buffer(z);
     }
 
     memmove(RSTRING_PTR(z->buf) + 1, RSTRING_PTR(z->buf), z->buf_filled);
     RSTRING_PTR(z->buf)[0] = (char)c;
     z->buf_filled++;
     if (z->stream.avail_out > 0) {
-        z->stream.next_out++;
-        z->stream.avail_out--;
+	z->stream.next_out++;
+	z->stream.avail_out--;
     }
 }
 
@@ -729,28 +833,29 @@ zstream_append_input(struct zstream *z, const Bytef *src, long len)
     if (len <= 0) return;
 
     if (NIL_P(z->input)) {
-        z->input = rb_str_buf_new(len);
-        rb_str_buf_cat(z->input, (const char*)src, len);
+	z->input = rb_str_buf_new(len);
+	rb_str_buf_cat(z->input, (const char*)src, len);
+	rb_obj_hide(z->input);
     }
     else {
-        rb_str_buf_cat(z->input, (const char*)src, len);
+	rb_str_buf_cat(z->input, (const char*)src, len);
     }
 }
 
 #define zstream_append_input2(z,v)\
-    RB_GC_GUARD(v) = v,\
+    RB_GC_GUARD(v),\
     zstream_append_input((z), (Bytef*)RSTRING_PTR(v), RSTRING_LEN(v))
 
 static void
 zstream_discard_input(struct zstream *z, long len)
 {
     if (NIL_P(z->input) || RSTRING_LEN(z->input) <= len) {
-        z->input = Qnil;
+	z->input = Qnil;
     }
     else {
-        memmove(RSTRING_PTR(z->input), RSTRING_PTR(z->input) + len,
-                RSTRING_LEN(z->input) - len);
-        rb_str_resize(z->input, RSTRING_LEN(z->input) - len);
+	memmove(RSTRING_PTR(z->input), RSTRING_PTR(z->input) + len,
+		RSTRING_LEN(z->input) - len);
+	rb_str_resize(z->input, RSTRING_LEN(z->input) - len);
     }
 }
 
@@ -764,8 +869,8 @@ static void
 zstream_passthrough_input(struct zstream *z)
 {
     if (!NIL_P(z->input)) {
-        zstream_append_buffer2(z, z->input);
-        z->input = Qnil;
+	zstream_append_buffer2(z, z->input);
+	z->input = Qnil;
     }
 }
 
@@ -775,12 +880,14 @@ zstream_detach_input(struct zstream *z)
     VALUE dst;
 
     if (NIL_P(z->input)) {
-        dst = rb_str_new(0, 0);
+	dst = rb_str_new(0, 0);
     }
     else {
-        dst = z->input;
+	dst = z->input;
+	rb_obj_reveal(dst, rb_cString);
     }
     z->input = Qnil;
+    rb_obj_reveal(dst, rb_cString);
     return dst;
 }
 
@@ -791,7 +898,7 @@ zstream_reset(struct zstream *z)
 
     err = z->func->reset(&z->stream);
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
     z->flags = ZSTREAM_FLAG_READY;
     z->buf = Qnil;
@@ -807,109 +914,173 @@ zstream_end(struct zstream *z)
     int err;
 
     if (!ZSTREAM_IS_READY(z)) {
-        rb_warning("attempt to close uninitialized zstream; ignored.");
-        return Qnil;
+	rb_warning("attempt to close uninitialized zstream; ignored.");
+	return Qnil;
     }
     if (z->flags & ZSTREAM_FLAG_IN_STREAM) {
-        rb_warning("attempt to close unfinished zstream; reset forced.");
-        zstream_reset(z);
+	rb_warning("attempt to close unfinished zstream; reset forced.");
+	zstream_reset(z);
     }
 
     zstream_reset_input(z);
     err = z->func->end(&z->stream);
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
     z->flags = 0;
     return Qnil;
 }
 
+static void *
+zstream_run_func(void *ptr)
+{
+    struct zstream_run_args *args = (struct zstream_run_args *)ptr;
+    int err, state, flush = args->flush;
+    struct zstream *z = args->z;
+    uInt n;
+
+    err = Z_OK;
+    while (!args->interrupt) {
+	n = z->stream.avail_out;
+	err = z->func->run(&z->stream, flush);
+	z->buf_filled += n - z->stream.avail_out;
+
+	if (err == Z_STREAM_END) {
+	    z->flags &= ~ZSTREAM_FLAG_IN_STREAM;
+	    z->flags |= ZSTREAM_FLAG_FINISHED;
+	    break;
+	}
+
+	if (err != Z_OK && err != Z_BUF_ERROR)
+	    break;
+
+	if (z->stream.avail_out > 0) {
+	    z->flags |= ZSTREAM_FLAG_IN_STREAM;
+	    break;
+	}
+
+	if (z->stream.avail_in == 0 && z->func == &inflate_funcs) {
+	    /* break here because inflate() return Z_BUF_ERROR when avail_in == 0. */
+	    /* but deflate() could be called with avail_in == 0 (there's hidden buffer
+	       in zstream->state) */
+	    z->flags |= ZSTREAM_FLAG_IN_STREAM;
+	    break;
+	}
+
+	state = (int)(VALUE)rb_thread_call_with_gvl(zstream_expand_buffer_protect,
+						    (void *)z);
+
+	if (state) {
+	    err = Z_OK; /* buffer expanded but stream processing was stopped */
+	    args->jump_state = state;
+	    break;
+	}
+    }
+
+    return (void *)(VALUE)err;
+}
+
+/*
+ * There is no safe way to interrupt z->run->func().
+ */
+static void
+zstream_unblock_func(void *ptr)
+{
+    struct zstream_run_args *args = (struct zstream_run_args *)ptr;
+
+    args->interrupt = 1;
+}
+
 static void
 zstream_run(struct zstream *z, Bytef *src, long len, int flush)
 {
-    uInt n;
+    struct zstream_run_args args;
     int err;
     volatile VALUE guard = Qnil;
 
+    args.z = z;
+    args.flush = flush;
+    args.interrupt = 0;
+    args.jump_state = 0;
+    args.stream_output = !ZSTREAM_IS_GZFILE(z) && rb_block_given_p();
+
     if (NIL_P(z->input) && len == 0) {
-        z->stream.next_in = (Bytef*)"";
-        z->stream.avail_in = 0;
+	z->stream.next_in = (Bytef*)"";
+	z->stream.avail_in = 0;
     }
     else {
-        zstream_append_input(z, src, len);
-        z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
-        z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
-        /* keep reference to `z->input' so as not to be garbage collected
-           after zstream_reset_input() and prevent `z->stream.next_in'
-           from dangling. */
-        guard = z->input;
+	zstream_append_input(z, src, len);
+	z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
+	z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
+	/* keep reference to `z->input' so as not to be garbage collected
+	   after zstream_reset_input() and prevent `z->stream.next_in'
+	   from dangling. */
+	guard = z->input;
     }
 
     if (z->stream.avail_out == 0) {
-        zstream_expand_buffer(z);
+	zstream_expand_buffer(z);
     }
 
-    for (;;) {
-        /* VC allocates err and guard to same address.  accessing err and guard
-           in same scope prevents it. */
-        RB_GC_GUARD(guard) = guard;
-        n = z->stream.avail_out;
-        err = z->func->run(&z->stream, flush);
-        z->buf_filled += n - z->stream.avail_out;
-        rb_thread_schedule();
-
-        if (err == Z_STREAM_END) {
-            z->flags &= ~ZSTREAM_FLAG_IN_STREAM;
-            z->flags |= ZSTREAM_FLAG_FINISHED;
-            break;
-        }
-        if (err != Z_OK) {
-            if (flush != Z_FINISH && err == Z_BUF_ERROR
-                && z->stream.avail_out > 0) {
-                z->flags |= ZSTREAM_FLAG_IN_STREAM;
-                break;
-            }
-            zstream_reset_input(z);
-            if (z->stream.avail_in > 0) {
-                zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
-            }
-            raise_zlib_error(err, z->stream.msg);
-        }
-        if (z->stream.avail_out > 0) {
-            z->flags |= ZSTREAM_FLAG_IN_STREAM;
-            break;
-        }
-        zstream_expand_buffer(z);
+loop:
+    err = (int)(VALUE)rb_thread_call_without_gvl(zstream_run_func, (void *)&args,
+						 zstream_unblock_func, (void *)&args);
+
+    if (flush != Z_FINISH && err == Z_BUF_ERROR
+	    && z->stream.avail_out > 0) {
+	z->flags |= ZSTREAM_FLAG_IN_STREAM;
     }
 
     zstream_reset_input(z);
+
+    if (err != Z_OK && err != Z_STREAM_END) {
+	if (z->stream.avail_in > 0) {
+	    zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
+	}
+	if (err == Z_NEED_DICT) {
+	    VALUE self = (VALUE)z->stream.opaque;
+	    if (self) {
+		VALUE dicts = rb_ivar_get(self, id_dictionaries);
+		VALUE dict = rb_hash_aref(dicts, rb_uint2inum(z->stream.adler));
+		if (!NIL_P(dict)) {
+		    rb_inflate_set_dictionary(self, dict);
+		    goto loop;
+		}
+	    }
+	}
+	raise_zlib_error(err, z->stream.msg);
+    }
+
     if (z->stream.avail_in > 0) {
-        zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
-        guard = Qnil; /* prevent tail call to make guard effective */
+	zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
+        RB_GC_GUARD(guard) = Qnil; /* prevent tail call to make guard effective */
     }
+
+    if (args.jump_state)
+	rb_jump_tag(args.jump_state);
 }
 
 static VALUE
 zstream_sync(struct zstream *z, Bytef *src, long len)
 {
-    VALUE rest;
+    /* VALUE rest; */
     int err;
 
     if (!NIL_P(z->input)) {
-        z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
-        z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
-        err = inflateSync(&z->stream);
-        if (err == Z_OK) {
-            zstream_discard_input(z,
-                                  RSTRING_LEN(z->input) - z->stream.avail_in);
-            zstream_append_input(z, src, len);
-            return Qtrue;
-        }
-        zstream_reset_input(z);
-        if (err != Z_DATA_ERROR) {
-            rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in);
-            raise_zlib_error(err, z->stream.msg);
-        }
+	z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
+	z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
+	err = inflateSync(&z->stream);
+	if (err == Z_OK) {
+	    zstream_discard_input(z,
+				  RSTRING_LEN(z->input) - z->stream.avail_in);
+	    zstream_append_input(z, src, len);
+	    return Qtrue;
+	}
+	zstream_reset_input(z);
+	if (err != Z_DATA_ERROR) {
+	    /* rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in); */
+	    raise_zlib_error(err, z->stream.msg);
+	}
     }
 
     if (len <= 0) return Qfalse;
@@ -918,12 +1089,12 @@ zstream_sync(struct zstream *z, Bytef *src, long len)
     z->stream.avail_in = MAX_UINT(len);
     err = inflateSync(&z->stream);
     if (err == Z_OK) {
-        zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
-        return Qtrue;
+	zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
+	return Qtrue;
     }
     if (err != Z_DATA_ERROR) {
-        rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in);
-        raise_zlib_error(err, z->stream.msg);
+	/* rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in); */
+	raise_zlib_error(err, z->stream.msg);
     }
     return Qfalse;
 }
@@ -940,16 +1111,16 @@ zstream_finalize(struct zstream *z)
 {
     int err = z->func->end(&z->stream);
     if (err == Z_STREAM_ERROR)
-        finalizer_warn("the stream state was inconsistent.");
+	finalizer_warn("the stream state was inconsistent.");
     if (err == Z_DATA_ERROR)
-        finalizer_warn("the stream was freed prematurely.");
+	finalizer_warn("the stream was freed prematurely.");
 }
 
 static void
 zstream_free(struct zstream *z)
 {
     if (ZSTREAM_IS_READY(z)) {
-        zstream_finalize(z);
+	zstream_finalize(z);
     }
     xfree(z);
 }
@@ -961,8 +1132,9 @@ zstream_new(VALUE klass, const struct zstream_funcs *funcs)
     struct zstream *z;
 
     obj = Data_Make_Struct(klass, struct zstream,
-                           zstream_mark, zstream_free, z);
+			   zstream_mark, zstream_free, z);
     zstream_init(z, funcs);
+    z->stream.opaque = (voidpf)obj;
     return obj;
 }
 
@@ -976,7 +1148,7 @@ get_zstream(VALUE obj)
 
     Data_Get_Struct(obj, struct zstream, z);
     if (!ZSTREAM_IS_READY(z)) {
-        rb_raise(cZError, "stream is not ready");
+	rb_raise(cZError, "stream is not ready");
     }
     return z;
 }
@@ -1068,24 +1240,28 @@ rb_zstream_reset(VALUE obj)
 }
 
 /*
- * Finishes the stream and flushes output buffer. See Zlib::Deflate#finish and
- * Zlib::Inflate#finish for details of this behavior.
+ * call-seq:
+ *   finish                 -> String
+ *   finish { |chunk| ... } -> nil
+ *
+ * Finishes the stream and flushes output buffer.  If a block is given each
+ * chunk is yielded to the block until the input buffer has been flushed to
+ * the output buffer.
  */
 static VALUE
 rb_zstream_finish(VALUE obj)
 {
     struct zstream *z = get_zstream(obj);
-    VALUE dst;
 
     zstream_run(z, (Bytef*)"", 0, Z_FINISH);
-    dst = zstream_detach_buffer(z);
 
-    OBJ_INFECT(dst, obj);
-    return dst;
+    return zstream_detach_buffer(z);
 }
 
 /*
- * Flushes input buffer and returns all data in that buffer.
+ * call-seq:
+ *   flush_next_in -> input
+ *
  */
 static VALUE
 rb_zstream_flush_next_in(VALUE obj)
@@ -1100,18 +1276,22 @@ rb_zstream_flush_next_in(VALUE obj)
 }
 
 /*
- * Flushes output buffer and returns all data in that buffer.
+ * call-seq:
+ *   flush_next_out                 -> String
+ *   flush_next_out { |chunk| ... } -> nil
+ *
+ * Flushes output buffer and returns all data in that buffer.  If a block is
+ * given each chunk is yielded to the block until the current output buffer
+ * has been flushed.
  */
 static VALUE
 rb_zstream_flush_next_out(VALUE obj)
 {
     struct zstream *z;
-    VALUE dst;
 
     Data_Get_Struct(obj, struct zstream, z);
-    dst = zstream_detach_buffer(z);
-    OBJ_INFECT(dst, obj);
-    return dst;
+
+    return zstream_detach_buffer(z);
 }
 
 /*
@@ -1188,7 +1368,7 @@ rb_zstream_data_type(VALUE obj)
 static VALUE
 rb_zstream_adler(VALUE obj)
 {
-        return rb_uint2inum(get_zstream(obj)->stream.adler);
+	return rb_uint2inum(get_zstream(obj)->stream.adler);
 }
 
 /*
@@ -1241,60 +1421,73 @@ rb_deflate_s_allocate(VALUE klass)
 /*
  * Document-method: Zlib::Deflate.new
  *
- * call-seq: Zlib::Deflate.new(level=nil, windowBits=nil, memlevel=nil, strategy=nil)
+ * call-seq:
+ *   Zlib::Deflate.new(level=DEFAULT_COMPRESSION, window_bits=MAX_WBITS, mem_level=DEF_MEM_LEVEL, strategy=DEFAULT_STRATEGY)
+ *
+ * Creates a new deflate stream for compression. If a given argument is nil,
+ * the default value of that argument is used.
  *
- * == Arguments
+ * The +level+ sets the compression level for the deflate stream between 0 (no
+ * compression) and 9 (best compression. The following constants have been
+ * defined to make code more readable:
  *
- * +level+::
- *   An Integer compression level between
- *   BEST_SPEED and BEST_COMPRESSION
- * +windowBits+::
- *   An Integer for the windowBits size. Should be
- *   in the range 8..15, larger values of this parameter
- *   result in better at the expense of memory usage.
- * +memlevel+::
- *   Specifies how much memory should be allocated for
- *   the internal compression state.
- *   Between DEF_MEM_LEVEL and MAX_MEM_LEVEL
- * +strategy+::
- *   A parameter to tune the compression algorithm. Use the
- *   DEFAULT_STRATEGY for normal data, FILTERED for data produced by a
- *   filter (or predictor), HUFFMAN_ONLY to force Huffman encoding only (no
- *   string match).
+ * * Zlib::NO_COMPRESSION = 0
+ * * Zlib::BEST_SPEED = 1
+ * * Zlib::DEFAULT_COMPRESSION = 6
+ * * Zlib::BEST_COMPRESSION = 9
  *
- * == Description
+ * The +window_bits+ sets the size of the history buffer and should be between
+ * 8 and 15.  Larger values of this parameter result in better compression at
+ * the expense of memory usage.
  *
- * Creates a new deflate stream for compression. See zlib.h for details of
- * each argument. If an argument is nil, the default value of that argument is
- * used.
+ * The +mem_level+ specifies how much memory should be allocated for the
+ * internal compression state.  1 uses minimum memory but is slow and reduces
+ * compression ratio while 9 uses maximum memory for optimal speed.  The
+ * default value is 8. Two constants are defined:
  *
+ * * Zlib::DEF_MEM_LEVEL
+ * * Zlib::MAX_MEM_LEVEL
  *
- * == examples
+ * The +strategy+ sets the deflate compression strategy.  The following
+ * strategies are available:
  *
- * === basic
+ * Zlib::DEFAULT_STRATEGY:: For normal data
+ * Zlib::FILTERED:: For data produced by a filter or predictor
+ * Zlib::FIXED:: Prevents dynamic Huffman codes
+ * Zlib::HUFFMAN_ONLY:: Prevents string matching
+ * Zlib::RLE:: Designed for better compression of PNG image data
  *
- *   f = File.new("compressed.file","w+")
- *   #=> #<File:compressed.file>
- *   f << Zlib::Deflate.new().deflate(File.read("big.file"))
- *   #=> #<File:compressed.file>
- *   f.close
- *   #=> nil
+ * See the constants for further description.
  *
- * === a little more robust
+ * == Examples
  *
- *   compressed_file = File.open("compressed.file", "w+")
- *   #=> #<File:compressed.file>
- *   zd = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, 15, Zlib::MAX_MEM_LEVEL, Zlib::HUFFMAN_ONLY)
- *   #=> #<Zlib::Deflate:0x000000008610a0>
- *   compressed_file << zd.deflate(File.read("big.file"))
- *   #=> "\xD4z\xC6\xDE\b\xA1K\x1Ej\x8A ..."
- *   compressed_file.close
- *   #=> nil
- *   zd.close
- *   #=> nil
+ * === Basic
  *
- * (while this example will work, for best optimization the flags need to be reviewed for your specific function)
+ *   open "compressed.file", "w+" do |io|
+ *     io << Zlib::Deflate.new.deflate(File.read("big.file"))
+ *   end
+ *
+ * === Custom compression
+ *
+ *   open "compressed.file", "w+" do |compressed_io|
+ *     deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
+ *                                 Zlib::MAX_WBITS,
+ *                                 Zlib::MAX_MEM_LEVEL,
+ *                                 Zlib::HUFFMAN_ONLY)
+ *
+ *     begin
+ *       open "big.file" do |big_io|
+ *         until big_io.eof? do
+ *           compressed_io << zd.deflate(big_io.read(16384))
+ *         end
+ *       end
+ *     ensure
+ *       deflate.close
+ *     end
+ *   end
  *
+ * While this example will work, for best optimization review the flags for
+ * your specific time, memory usage and output space requirements.
  */
 static VALUE
 rb_deflate_initialize(int argc, VALUE *argv, VALUE obj)
@@ -1307,10 +1500,10 @@ rb_deflate_initialize(int argc, VALUE *argv, VALUE obj)
     Data_Get_Struct(obj, struct zstream, z);
 
     err = deflateInit2(&z->stream, ARG_LEVEL(level), Z_DEFLATED,
-                       ARG_WBITS(wbits), ARG_MEMLEVEL(memlevel),
-                       ARG_STRATEGY(strategy));
+		       ARG_WBITS(wbits), ARG_MEMLEVEL(memlevel),
+		       ARG_STRATEGY(strategy));
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
     ZSTREAM_READY(z);
 
@@ -1333,7 +1526,7 @@ rb_deflate_init_copy(VALUE self, VALUE orig)
 
     err = deflateCopy(&z1->stream, &z2->stream);
     if (err != Z_OK) {
-        raise_zlib_error(err, 0);
+	raise_zlib_error(err, 0);
     }
     z1->input = NIL_P(z2->input) ? Qnil : rb_str_dup(z2->input);
     z1->buf   = NIL_P(z2->buf)   ? Qnil : rb_str_dup(z2->buf);
@@ -1356,19 +1549,19 @@ deflate_run(VALUE args)
 /*
  * Document-method: Zlib::Deflate.deflate
  *
- * call-seq: Zlib.deflate(string[, level])
- *           Zlib::Deflate.deflate(string[, level])
+ * call-seq:
+ *   Zlib.deflate(string[, level])
+ *   Zlib::Deflate.deflate(string[, level])
  *
  * Compresses the given +string+. Valid values of level are
- * <tt>NO_COMPRESSION</tt>, <tt>BEST_SPEED</tt>,
- * <tt>BEST_COMPRESSION</tt>, <tt>DEFAULT_COMPRESSION</tt>, and an
- * integer from 0 to 9 (the default is 6).
+ * Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION,
+ * Zlib::DEFAULT_COMPRESSION, or an integer from 0 to 9 (the default is 6).
  *
  * This method is almost equivalent to the following code:
  *
  *   def deflate(string, level)
  *     z = Zlib::Deflate.new(level)
- *     dst = z.deflate(string, Zlib::NO_FLUSH)
+ *     dst = z.deflate(string, Zlib::FINISH)
  *     z.close
  *     dst
  *   end
@@ -1390,7 +1583,7 @@ rb_deflate_s_deflate(int argc, VALUE *argv, VALUE klass)
     zstream_init_deflate(&z);
     err = deflateInit(&z.stream, lev);
     if (err != Z_OK) {
-        raise_zlib_error(err, z.stream.msg);
+	raise_zlib_error(err, z.stream.msg);
     }
     ZSTREAM_READY(&z);
 
@@ -1406,65 +1599,56 @@ static void
 do_deflate(struct zstream *z, VALUE src, int flush)
 {
     if (NIL_P(src)) {
-        zstream_run(z, (Bytef*)"", 0, Z_FINISH);
-        return;
+	zstream_run(z, (Bytef*)"", 0, Z_FINISH);
+	return;
     }
     StringValue(src);
     if (flush != Z_NO_FLUSH || RSTRING_LEN(src) > 0) { /* prevent BUF_ERROR */
-        zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), flush);
+	zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), flush);
     }
 }
 
 /*
- * Document-method: Zlib.deflate
+ * Document-method: Zlib::Deflate#deflate
  *
- * call-seq: deflate(string[, flush])
- *
- * == Arguments
- *
- * +string+::
- *   String
- *
- * +flush+::
- *   Integer representing a flush code. Either NO_FLUSH,
- *   SYNC_FLUSH, FULL_FLUSH, or FINISH. See zlib.h for details.
- *   Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
- *   decide how much data to accumulate before producing output, in order to
- *   maximize compression.
- *
- * == Description
+ * call-seq:
+ *   z.deflate(string, flush = Zlib::NO_FLUSH)                 -> String
+ *   z.deflate(string, flush = Zlib::NO_FLUSH) { |chunk| ... } -> nil
  *
  * Inputs +string+ into the deflate stream and returns the output from the
  * stream.  On calling this method, both the input and the output buffers of
- * the stream are flushed.
- *
- * If +string+ is nil, this method finishes the
+ * the stream are flushed.  If +string+ is nil, this method finishes the
  * stream, just like Zlib::ZStream#finish.
  *
- * == Usage
+ * If a block is given consecutive deflated chunks from the +string+ are
+ * yielded to the block and +nil+ is returned.
+ *
+ * The +flush+ parameter specifies the flush mode.  The following constants
+ * may be used:
  *
- *   comp = Zlib.deflate(File.read("big.file"))
- * or
- *   comp = Zlib.deflate(File.read("big.file"), Zlib::FULL_FLUSH)
+ * Zlib::NO_FLUSH:: The default
+ * Zlib::SYNC_FLUSH:: Flushes the output to a byte boundary
+ * Zlib::FULL_FLUSH:: SYNC_FLUSH + resets the compression state
+ * Zlib::FINISH:: Pending input is processed, pending output is flushed.
+ *
+ * See the constants for further description.
  *
  */
 static VALUE
 rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
 {
     struct zstream *z = get_zstream(obj);
-    VALUE src, flush, dst;
+    VALUE src, flush;
 
     rb_scan_args(argc, argv, "11", &src, &flush);
     OBJ_INFECT(obj, src);
     do_deflate(z, src, ARG_FLUSH(flush));
-    dst = zstream_detach_buffer(z);
 
-    OBJ_INFECT(dst, obj);
-    return dst;
+    return zstream_detach_buffer(z);
 }
 
 /*
- * Document-method: Zlib::Deflate.<<
+ * Document-method: Zlib::Deflate#<<
  *
  * call-seq: << string
  *
@@ -1483,31 +1667,32 @@ rb_deflate_addstr(VALUE obj, VALUE src)
 /*
  * Document-method: Zlib::Deflate#flush
  *
- * call-seq: flush(flush)
+ * call-seq:
+ *   flush(flush = Zlib::SYNC_FLUSH)                 -> String
+ *   flush(flush = Zlib::SYNC_FLUSH) { |chunk| ... } -> nil
  *
- * This method is equivalent to <tt>deflate('', flush)</tt>.  If flush is omitted,
- * <tt>SYNC_FLUSH</tt> is used as flush.  This method is just provided
- * to improve the readability of your Ruby program.
- *
- * Please visit your zlib.h for a deeper detail on NO_FLUSH, SYNC_FLUSH, FULL_FLUSH, and FINISH
+ * This method is equivalent to <tt>deflate('', flush)</tt>. This method is
+ * just provided to improve the readability of your Ruby program.  If a block
+ * is given chunks of deflate output are yielded to the block until the buffer
+ * is flushed.
  *
+ * See Zlib::Deflate#deflate for detail on the +flush+ constants NO_FLUSH,
+ * SYNC_FLUSH, FULL_FLUSH and FINISH.
  */
 static VALUE
 rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
 {
     struct zstream *z = get_zstream(obj);
-    VALUE v_flush, dst;
+    VALUE v_flush;
     int flush;
 
     rb_scan_args(argc, argv, "01", &v_flush);
     flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
     if (flush != Z_NO_FLUSH) {  /* prevent Z_BUF_ERROR */
-        zstream_run(z, (Bytef*)"", 0, flush);
+	zstream_run(z, (Bytef*)"", 0, flush);
     }
-    dst = zstream_detach_buffer(z);
 
-    OBJ_INFECT(dst, obj);
-    return dst;
+    return zstream_detach_buffer(z);
 }
 
 /*
@@ -1515,18 +1700,11 @@ rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
  *
  * call-seq: params(level, strategy)
  *
- * Changes the parameters of the deflate stream. See zlib.h for details. The
- * output from the stream by changing the params is preserved in output
- * buffer.
+ * Changes the parameters of the deflate stream to allow changes between
+ * different types of data that require different types of compression.  Any
+ * unprocessed data is flushed before changing the params.
  *
- * +level+::
- *   An Integer compression level between
- *   BEST_SPEED and BEST_COMPRESSION
- * +strategy+::
- *   A parameter to tune the compression algorithm. Use the
- *   DEFAULT_STRATEGY for normal data, FILTERED for data produced by a
- *   filter (or predictor), HUFFMAN_ONLY to force Huffman encoding only (no
- *   string match).
+ * See Zlib::Deflate.new for a description of +level+ and +strategy+.
  *
  */
 static VALUE
@@ -1544,14 +1722,14 @@ rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy)
     err = deflateParams(&z->stream, level, strategy);
     z->buf_filled += n - z->stream.avail_out;
     while (err == Z_BUF_ERROR) {
-        rb_warning("deflateParams() returned Z_BUF_ERROR");
-        zstream_expand_buffer(z);
-        n = z->stream.avail_out;
-        err = deflateParams(&z->stream, level, strategy);
-        z->buf_filled += n - z->stream.avail_out;
+	rb_warning("deflateParams() returned Z_BUF_ERROR");
+	zstream_expand_buffer(z);
+	n = z->stream.avail_out;
+	err = deflateParams(&z->stream, level, strategy);
+	z->buf_filled += n - z->stream.avail_out;
     }
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
 
     return Qnil;
@@ -1581,9 +1759,9 @@ rb_deflate_set_dictionary(VALUE obj, VALUE dic)
     OBJ_INFECT(obj, dic);
     StringValue(src);
     err = deflateSetDictionary(&z->stream,
-                               (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
+			       (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
 
     return dic;
@@ -1600,52 +1778,57 @@ rb_deflate_set_dictionary(VALUE obj, VALUE dic)
  * dup) itself.
  */
 
-
-
 static VALUE
 rb_inflate_s_allocate(VALUE klass)
 {
-    return zstream_inflate_new(klass);
+    VALUE inflate = zstream_inflate_new(klass);
+    rb_ivar_set(inflate, id_dictionaries, rb_hash_new());
+    return inflate;
 }
 
 /*
  * Document-method: Zlib::Inflate.new
  *
- * call-seq: Zlib::Inflate.new(window_bits)
+ * call-seq:
+ *   Zlib::Inflate.new(window_bits = Zlib::MAX_WBITS)
  *
- * == Arguments
+ * Creates a new inflate stream for decompression.  +window_bits+ sets the
+ * size of the history buffer and can have the following values:
  *
- * +windowBits+::
- *   An Integer for the windowBits size. Should be
- *   in the range 8..15, larger values of this parameter
- *   result in better at the expense of memory usage.
+ * 0::
+ *   Have inflate use the window size from the zlib header of the compressed
+ *   stream.
  *
- * == Description
+ * (8..15)
+ *   Overrides the window size of the inflate header in the compressed stream.
+ *   The window size must be greater than or equal to the window size of the
+ *   compressed stream.
  *
- * Creates a new inflate stream for decompression. See zlib.h for details
- * of the argument.  If +window_bits+ is +nil+, the default value is used.
- *
- * == Example
+ * Greater than 15::
+ *   Add 32 to window_bits to enable zlib and gzip decoding with automatic
+ *   header detection, or add 16 to decode only the gzip format (a
+ *   Zlib::DataError will be raised for a non-gzip stream).
  *
- *   cf = File.open("compressed.file")
- *   ucf = File.open("uncompressed.file", "w+")
- *   zi = Zlib::Inflate.new(Zlib::MAX_WBITS)
+ * (-8..-15)::
+ *   Enables raw deflate mode which will not generate a check value, and will
+ *   not look for any check values for comparison at the end of the stream.
  *
- *   ucf << zi.inflate(cf.read)
+ *   This is for use with other formats that use the deflate compressed data
+ *   format such as zip which provide their own check values.
  *
- *   ucf.close
- *   zi.close
- *   cf.close
+ * == Example
  *
- * or
+ *   open "compressed.file" do |compressed_io|
+ *     zi = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
  *
- *   File.open("compressed.file") {|cf|
- *     zi = Zlib::Inflate.new
- *     File.open("uncompressed.file", "w+") {|ucf|
- *       ucf << zi.inflate(cf.read)
- *     }
- *     zi.close
- *   }
+ *     begin
+ *       open "uncompressed.file", "w+" do |uncompressed_io|
+ *         uncompressed_io << zi.inflate(compressed_io.read)
+ *       end
+ *     ensure
+ *       zi.close
+ *     end
+ *   end
  *
  */
 static VALUE
@@ -1660,7 +1843,7 @@ rb_inflate_initialize(int argc, VALUE *argv, VALUE obj)
 
     err = inflateInit2(&z->stream, ARG_WBITS(wbits));
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
     ZSTREAM_READY(z);
 
@@ -1679,9 +1862,11 @@ inflate_run(VALUE args)
 }
 
 /*
- * Document-method: Zlib::Inflate.inflate
+ * Document-method: Zlib::inflate
  *
- * call-seq: Zlib::Inflate.inflate(string)
+ * call-seq:
+ *   Zlib.inflate(string)
+ *   Zlib::Inflate.inflate(string)
  *
  * Decompresses +string+. Raises a Zlib::NeedDict exception if a preset
  * dictionary is needed for decompression.
@@ -1710,7 +1895,7 @@ rb_inflate_s_inflate(VALUE obj, VALUE src)
     zstream_init_inflate(&z);
     err = inflateInit(&z.stream);
     if (err != Z_OK) {
-        raise_zlib_error(err, z.stream.msg);
+	raise_zlib_error(err, z.stream.msg);
     }
     ZSTREAM_READY(&z);
 
@@ -1726,28 +1911,68 @@ static void
 do_inflate(struct zstream *z, VALUE src)
 {
     if (NIL_P(src)) {
-        zstream_run(z, (Bytef*)"", 0, Z_FINISH);
-        return;
+	zstream_run(z, (Bytef*)"", 0, Z_FINISH);
+	return;
     }
     StringValue(src);
-    if (RSTRING_LEN(src) > 0) { /* prevent Z_BUF_ERROR */
-        zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_SYNC_FLUSH);
+    if (RSTRING_LEN(src) > 0 || z->stream.avail_in > 0) { /* prevent Z_BUF_ERROR */
+	zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_SYNC_FLUSH);
     }
 }
 
+/* Document-method: Zlib::Inflate#add_dictionary
+ *
+ * call-seq: add_dictionary(string)
+ *
+ * Provide the inflate stream with a dictionary that may be required in the
+ * future.  Multiple dictionaries may be provided.  The inflate stream will
+ * automatically choose the correct user-provided dictionary based on the
+ * stream's required dictionary.
+ */
+static VALUE
+rb_inflate_add_dictionary(VALUE obj, VALUE dictionary) {
+    VALUE dictionaries = rb_ivar_get(obj, id_dictionaries);
+    VALUE checksum = do_checksum(1, &dictionary, adler32);
+
+    rb_hash_aset(dictionaries, checksum, dictionary);
+
+    return obj;
+}
+
 /*
  * Document-method: Zlib::Inflate#inflate
  *
- * call-seq: inflate(string)
+ * call-seq:
+ *   inflate(deflate_string)                 -> String
+ *   inflate(deflate_string) { |chunk| ... } -> nil
+ *
+ * Inputs +deflate_string+ into the inflate stream and returns the output from
+ * the stream.  Calling this method, both the input and the output buffer of
+ * the stream are flushed.  If string is +nil+, this method finishes the
+ * stream, just like Zlib::ZStream#finish.
  *
- * Inputs +string+ into the inflate stream and returns the output from the
- * stream.  Calling this method, both the input and the output buffer of the
- * stream are flushed.  If string is +nil+, this method finishes the stream,
- * just like Zlib::ZStream#finish.
+ * If a block is given consecutive inflated chunks from the +deflate_string+
+ * are yielded to the block and +nil+ is returned.
  *
  * Raises a Zlib::NeedDict exception if a preset dictionary is needed to
  * decompress.  Set the dictionary by Zlib::Inflate#set_dictionary and then
- * call this method again with an empty string.  (<i>???</i>)
+ * call this method again with an empty string to flush the stream:
+ *
+ *   inflater = Zlib::Inflate.new
+ *
+ *   begin
+ *     out = inflater.inflate compressed
+ *   rescue Zlib::NeedDict
+ *     # ensure the dictionary matches the stream's required dictionary
+ *     raise unless inflater.adler == Zlib.adler32(dictionary)
+ *
+ *     inflater.set_dictionary dictionary
+ *     inflater.inflate ''
+ *   end
+ *
+ *   # ...
+ *
+ *   inflater.close
  *
  * See also Zlib::Inflate.new
  */
@@ -1760,24 +1985,24 @@ rb_inflate_inflate(VALUE obj, VALUE src)
     OBJ_INFECT(obj, src);
 
     if (ZSTREAM_IS_FINISHED(z)) {
-        if (NIL_P(src)) {
-            dst = zstream_detach_buffer(z);
-        }
-        else {
-            StringValue(src);
-            zstream_append_buffer2(z, src);
-            dst = rb_str_new(0, 0);
-        }
+	if (NIL_P(src)) {
+	    dst = zstream_detach_buffer(z);
+	}
+	else {
+	    StringValue(src);
+	    zstream_append_buffer2(z, src);
+	    dst = rb_str_new(0, 0);
+	    OBJ_INFECT(dst, obj);
+	}
     }
     else {
-        do_inflate(z, src);
-        dst = zstream_detach_buffer(z);
-        if (ZSTREAM_IS_FINISHED(z)) {
-            zstream_passthrough_input(z);
-        }
+	do_inflate(z, src);
+	dst = zstream_detach_buffer(z);
+	if (ZSTREAM_IS_FINISHED(z)) {
+	    zstream_passthrough_input(z);
+	}
     }
 
-    OBJ_INFECT(dst, obj);
     return dst;
 }
 
@@ -1796,16 +2021,16 @@ rb_inflate_addstr(VALUE obj, VALUE src)
     OBJ_INFECT(obj, src);
 
     if (ZSTREAM_IS_FINISHED(z)) {
-        if (!NIL_P(src)) {
-            StringValue(src);
-            zstream_append_buffer2(z, src);
-        }
+	if (!NIL_P(src)) {
+	    StringValue(src);
+	    zstream_append_buffer2(z, src);
+	}
     }
     else {
-        do_inflate(z, src);
-        if (ZSTREAM_IS_FINISHED(z)) {
-            zstream_passthrough_input(z);
-        }
+	do_inflate(z, src);
+	if (ZSTREAM_IS_FINISHED(z)) {
+	    zstream_passthrough_input(z);
+	}
     }
 
     return obj;
@@ -1844,10 +2069,10 @@ rb_inflate_sync_point_p(VALUE obj)
 
     err = inflateSyncPoint(&z->stream);
     if (err == 1) {
-        return Qtrue;
+	return Qtrue;
     }
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
     return Qfalse;
 }
@@ -1869,9 +2094,9 @@ rb_inflate_set_dictionary(VALUE obj, VALUE dic)
     OBJ_INFECT(obj, dic);
     StringValue(src);
     err = inflateSetDictionary(&z->stream,
-                               (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
+			       (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
     if (err != Z_OK) {
-        raise_zlib_error(err, z->stream.msg);
+	raise_zlib_error(err, z->stream.msg);
     }
 
     return dic;
@@ -1979,13 +2204,13 @@ gzfile_free(struct gzfile *gz)
     struct zstream *z = &gz->z;
 
     if (ZSTREAM_IS_READY(z)) {
-        if (z->func == &deflate_funcs) {
-            finalizer_warn("Zlib::GzipWriter object must be closed explicitly.");
-        }
-        zstream_finalize(z);
+	if (z->func == &deflate_funcs) {
+	    finalizer_warn("Zlib::GzipWriter object must be closed explicitly.");
+	}
+	zstream_finalize(z);
     }
     if (gz->cbuf) {
-        xfree(gz->cbuf);
+	xfree(gz->cbuf);
     }
     xfree(gz);
 }
@@ -2001,6 +2226,7 @@ gzfile_new(klass, funcs, endfunc)
 
     obj = Data_Make_Struct(klass, struct gzfile, gzfile_mark, gzfile_free, gz);
     zstream_init(&gz->z, funcs);
+    gz->z.flags |= ZSTREAM_FLAG_GZFILE;
     gz->io = Qnil;
     gz->level = 0;
     gz->mtime = 0;
@@ -2033,11 +2259,10 @@ gzfile_reset(struct gzfile *gz)
     gz->lineno = 0;
     gz->ungetc = 0;
     /* TODO: Encodings
-     *
     if (gz->ec) {
-        rb_econv_close(gz->ec);
-        gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
-                                    gz->ecflags, gz->ecopts);
+	rb_econv_close(gz->ec);
+	gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
+				    gz->ecflags, gz->ecopts);
     }
     */
 }
@@ -2052,7 +2277,7 @@ gzfile_close(struct gzfile *gz, int closeflag)
     gz->orig_name = Qnil;
     gz->comment = Qnil;
     if (closeflag && rb_respond_to(io, id_close)) {
-        rb_funcall(io, id_close, 0);
+	rb_funcall(io, id_close, 0);
     }
 }
 
@@ -2062,12 +2287,12 @@ gzfile_write_raw(struct gzfile *gz)
     VALUE str;
 
     if (gz->z.buf_filled > 0) {
-        str = zstream_detach_buffer(&gz->z);
-        OBJ_TAINT(str);  /* for safe */
-        rb_funcall(gz->io, id_write, 1, str);
-        if ((gz->z.flags & GZFILE_FLAG_SYNC)
-            && rb_respond_to(gz->io, id_flush))
-            rb_funcall(gz->io, id_flush, 0);
+	str = zstream_detach_buffer(&gz->z);
+	OBJ_TAINT(str);  /* for safe */
+	rb_funcall(gz->io, id_write, 1, str);
+	if ((gz->z.flags & GZFILE_FLAG_SYNC)
+	    && rb_respond_to(gz->io, id_flush))
+	    rb_funcall(gz->io, id_flush, 0);
     }
 }
 
@@ -2110,9 +2335,9 @@ gzfile_read_raw_ensure(struct gzfile *gz, long size)
     VALUE str;
 
     while (NIL_P(gz->z.input) || RSTRING_LEN(gz->z.input) < size) {
-        str = gzfile_read_raw(gz);
-        if (NIL_P(str)) return 0;
-        zstream_append_input2(&gz->z, str);
+	str = gzfile_read_raw(gz);
+	if (NIL_P(str)) return 0;
+	zstream_append_input2(&gz->z, str);
     }
     return 1;
 }
@@ -2124,15 +2349,15 @@ gzfile_read_raw_until_zero(struct gzfile *gz, long offset)
     char *p;
 
     for (;;) {
-        p = memchr(RSTRING_PTR(gz->z.input) + offset, '\0',
-                   RSTRING_LEN(gz->z.input) - offset);
-        if (p) break;
-        str = gzfile_read_raw(gz);
-        if (NIL_P(str)) {
-            rb_raise(cGzError, "unexpected end of file");
-        }
-        offset = RSTRING_LEN(gz->z.input);
-        zstream_append_input2(&gz->z, str);
+	p = memchr(RSTRING_PTR(gz->z.input) + offset, '\0',
+		   RSTRING_LEN(gz->z.input) - offset);
+	if (p) break;
+	str = gzfile_read_raw(gz);
+	if (NIL_P(str)) {
+	    rb_raise(cGzError, "unexpected end of file");
+	}
+	offset = RSTRING_LEN(gz->z.input);
+	zstream_append_input2(&gz->z, str);
     }
     return p;
 }
@@ -2171,7 +2396,7 @@ gzfile_raise(struct gzfile *gz, VALUE klass, const char *message)
 {
     VALUE exc = rb_exc_new2(klass, message);
     if (!NIL_P(gz->z.input)) {
-        rb_ivar_set(exc, id_input, rb_str_dup(gz->z.input));
+	rb_ivar_set(exc, id_input, rb_str_resurrect(gz->z.input));
     }
     rb_exc_raise(exc);
 }
@@ -2188,10 +2413,10 @@ gzfile_error_inspect(VALUE error)
     VALUE input = rb_attr_get(error, id_input);
 
     if (!NIL_P(input)) {
-        rb_str_resize(str, RSTRING_LEN(str)-1);
-        rb_str_cat2(str, ", input=");
-        rb_str_append(str, rb_str_inspect(input));
-        rb_str_cat2(str, ">");
+	rb_str_resize(str, RSTRING_LEN(str)-1);
+	rb_str_cat2(str, ", input=");
+	rb_str_append(str, rb_str_inspect(input));
+	rb_str_cat2(str, ">");
     }
     return str;
 }
@@ -2203,20 +2428,20 @@ gzfile_make_header(struct gzfile *gz)
     unsigned char flags = 0, extraflags = 0;
 
     if (!NIL_P(gz->orig_name)) {
-        flags |= GZ_FLAG_ORIG_NAME;
+	flags |= GZ_FLAG_ORIG_NAME;
     }
     if (!NIL_P(gz->comment)) {
-        flags |= GZ_FLAG_COMMENT;
+	flags |= GZ_FLAG_COMMENT;
     }
     if (gz->mtime == 0) {
-        gz->mtime = time(0);
+	gz->mtime = time(0);
     }
 
     if (gz->level == Z_BEST_SPEED) {
-        extraflags |= GZ_EXTRAFLAG_FAST;
+	extraflags |= GZ_EXTRAFLAG_FAST;
     }
     else if (gz->level == Z_BEST_COMPRESSION) {
-        extraflags |= GZ_EXTRAFLAG_SLOW;
+	extraflags |= GZ_EXTRAFLAG_SLOW;
     }
 
     buf[0] = GZ_MAGIC1;
@@ -2229,12 +2454,12 @@ gzfile_make_header(struct gzfile *gz)
     zstream_append_buffer(&gz->z, buf, sizeof(buf));
 
     if (!NIL_P(gz->orig_name)) {
-        zstream_append_buffer2(&gz->z, gz->orig_name);
-        zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
+	zstream_append_buffer2(&gz->z, gz->orig_name);
+	zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
     }
     if (!NIL_P(gz->comment)) {
-        zstream_append_buffer2(&gz->z, gz->comment);
-        zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
+	zstream_append_buffer2(&gz->z, gz->comment);
+	zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
     }
 
     gz->z.flags |= GZFILE_FLAG_HEADER_FINISHED;
@@ -2259,37 +2484,37 @@ gzfile_read_header(struct gzfile *gz)
     char flags, *p;
 
     if (!gzfile_read_raw_ensure(gz, 10)) {  /* 10 is the size of gzip header */
-        gzfile_raise(gz, cGzError, "not in gzip format");
+	gzfile_raise(gz, cGzError, "not in gzip format");
     }
 
     head = (unsigned char*)RSTRING_PTR(gz->z.input);
 
     if (head[0] != GZ_MAGIC1 || head[1] != GZ_MAGIC2) {
-        gzfile_raise(gz, cGzError, "not in gzip format");
+	gzfile_raise(gz, cGzError, "not in gzip format");
     }
     if (head[2] != GZ_METHOD_DEFLATE) {
-        rb_raise(cGzError, "unsupported compression method %d", head[2]);
+	rb_raise(cGzError, "unsupported compression method %d", head[2]);
     }
 
     flags = head[3];
     if (flags & GZ_FLAG_MULTIPART) {
-        rb_raise(cGzError, "multi-part gzip file is not supported");
+	rb_raise(cGzError, "multi-part gzip file is not supported");
     }
     else if (flags & GZ_FLAG_ENCRYPT) {
-        rb_raise(cGzError, "encrypted gzip file is not supported");
+	rb_raise(cGzError, "encrypted gzip file is not supported");
     }
     else if (flags & GZ_FLAG_UNKNOWN_MASK) {
-        rb_raise(cGzError, "unknown flags 0x%02x", flags);
+	rb_raise(cGzError, "unknown flags 0x%02x", flags);
     }
 
     if (head[8] & GZ_EXTRAFLAG_FAST) {
-        gz->level = Z_BEST_SPEED;
+	gz->level = Z_BEST_SPEED;
     }
     else if (head[8] & GZ_EXTRAFLAG_SLOW) {
-        gz->level = Z_BEST_COMPRESSION;
+	gz->level = Z_BEST_COMPRESSION;
     }
     else {
-        gz->level = Z_DEFAULT_COMPRESSION;
+	gz->level = Z_DEFAULT_COMPRESSION;
     }
 
     gz->mtime = gzfile_get32(&head[4]);
@@ -2297,38 +2522,38 @@ gzfile_read_header(struct gzfile *gz)
     zstream_discard_input(&gz->z, 10);
 
     if (flags & GZ_FLAG_EXTRA) {
-        if (!gzfile_read_raw_ensure(gz, 2)) {
-            rb_raise(cGzError, "unexpected end of file");
-        }
-        len = gzfile_get16((Bytef*)RSTRING_PTR(gz->z.input));
-        if (!gzfile_read_raw_ensure(gz, 2 + len)) {
-            rb_raise(cGzError, "unexpected end of file");
-        }
-        zstream_discard_input(&gz->z, 2 + len);
+	if (!gzfile_read_raw_ensure(gz, 2)) {
+	    rb_raise(cGzError, "unexpected end of file");
+	}
+	len = gzfile_get16((Bytef*)RSTRING_PTR(gz->z.input));
+	if (!gzfile_read_raw_ensure(gz, 2 + len)) {
+	    rb_raise(cGzError, "unexpected end of file");
+	}
+	zstream_discard_input(&gz->z, 2 + len);
     }
     if (flags & GZ_FLAG_ORIG_NAME) {
-        if (!gzfile_read_raw_ensure(gz, 1)) {
-            rb_raise(cGzError, "unexpected end of file");
-        }
-        p = gzfile_read_raw_until_zero(gz, 0);
-        len = p - RSTRING_PTR(gz->z.input);
-        gz->orig_name = rb_str_new(RSTRING_PTR(gz->z.input), len);
-        OBJ_TAINT(gz->orig_name);  /* for safe */
-        zstream_discard_input(&gz->z, len + 1);
+	if (!gzfile_read_raw_ensure(gz, 1)) {
+	    rb_raise(cGzError, "unexpected end of file");
+	}
+	p = gzfile_read_raw_until_zero(gz, 0);
+	len = p - RSTRING_PTR(gz->z.input);
+	gz->orig_name = rb_str_new(RSTRING_PTR(gz->z.input), len);
+	OBJ_TAINT(gz->orig_name);  /* for safe */
+	zstream_discard_input(&gz->z, len + 1);
     }
     if (flags & GZ_FLAG_COMMENT) {
-        if (!gzfile_read_raw_ensure(gz, 1)) {
-            rb_raise(cGzError, "unexpected end of file");
-        }
-        p = gzfile_read_raw_until_zero(gz, 0);
-        len = p - RSTRING_PTR(gz->z.input);
-        gz->comment = rb_str_new(RSTRING_PTR(gz->z.input), len);
-        OBJ_TAINT(gz->comment);  /* for safe */
-        zstream_discard_input(&gz->z, len + 1);
+	if (!gzfile_read_raw_ensure(gz, 1)) {
+	    rb_raise(cGzError, "unexpected end of file");
+	}
+	p = gzfile_read_raw_until_zero(gz, 0);
+	len = p - RSTRING_PTR(gz->z.input);
+	gz->comment = rb_str_new(RSTRING_PTR(gz->z.input), len);
+	OBJ_TAINT(gz->comment);  /* for safe */
+	zstream_discard_input(&gz->z, len + 1);
     }
 
     if (gz->z.input != Qnil && RSTRING_LEN(gz->z.input) > 0) {
-        zstream_run(&gz->z, 0, 0, Z_SYNC_FLUSH);
+	zstream_run(&gz->z, 0, 0, Z_SYNC_FLUSH);
     }
 }
 
@@ -2340,7 +2565,7 @@ gzfile_check_footer(struct gzfile *gz)
     gz->z.flags |= GZFILE_FLAG_FOOTER_FINISHED;
 
     if (!gzfile_read_raw_ensure(gz, 8)) { /* 8 is the size of gzip footer */
-        gzfile_raise(gz, cNoFooter, "footer is not found");
+	gzfile_raise(gz, cNoFooter, "footer is not found");
     }
 
     crc = gzfile_get32((Bytef*)RSTRING_PTR(gz->z.input));
@@ -2350,10 +2575,10 @@ gzfile_check_footer(struct gzfile *gz)
     zstream_discard_input(&gz->z, 8);
 
     if (gz->crc != crc) {
-        rb_raise(cCRCError, "invalid compressed data -- crc error");
+	rb_raise(cCRCError, "invalid compressed data -- crc error");
     }
     if ((uint32_t)gz->z.stream.total_out != length) {
-        rb_raise(cLengthError, "invalid compressed data -- length error");
+	rb_raise(cLengthError, "invalid compressed data -- length error");
     }
 }
 
@@ -2361,13 +2586,13 @@ static void
 gzfile_write(struct gzfile *gz, Bytef *str, long len)
 {
     if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
-        gzfile_make_header(gz);
+	gzfile_make_header(gz);
     }
 
     if (len > 0 || (gz->z.flags & GZFILE_FLAG_SYNC)) {
-        gz->crc = checksum_long(crc32, gz->crc, str, len);
-        zstream_run(&gz->z, str, len, (gz->z.flags & GZFILE_FLAG_SYNC)
-                    ? Z_SYNC_FLUSH : Z_NO_FLUSH);
+	gz->crc = checksum_long(crc32, gz->crc, str, len);
+	zstream_run(&gz->z, str, len, (gz->z.flags & GZFILE_FLAG_SYNC)
+		    ? Z_SYNC_FLUSH : Z_NO_FLUSH);
     }
     gzfile_write_raw(gz);
 }
@@ -2378,18 +2603,18 @@ gzfile_read_more(struct gzfile *gz)
     volatile VALUE str;
 
     while (!ZSTREAM_IS_FINISHED(&gz->z)) {
-        str = gzfile_read_raw(gz);
-        if (NIL_P(str)) {
-            if (!ZSTREAM_IS_FINISHED(&gz->z)) {
-                rb_raise(cGzError, "unexpected end of file");
-            }
-            break;
-        }
-        if (RSTRING_LEN(str) > 0) { /* prevent Z_BUF_ERROR */
-            zstream_run(&gz->z, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str),
-                        Z_SYNC_FLUSH);
-        }
-        if (gz->z.buf_filled > 0) break;
+	str = gzfile_read_raw(gz);
+	if (NIL_P(str)) {
+	    if (!ZSTREAM_IS_FINISHED(&gz->z)) {
+		rb_raise(cGzError, "unexpected end of file");
+	    }
+	    break;
+	}
+	if (RSTRING_LEN(str) > 0) { /* prevent Z_BUF_ERROR */
+	    zstream_run(&gz->z, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str),
+			Z_SYNC_FLUSH);
+	}
+	if (gz->z.buf_filled > 0) break;
     }
     return gz->z.buf_filled;
 }
@@ -2398,12 +2623,12 @@ static void
 gzfile_calc_crc(struct gzfile *gz, VALUE str)
 {
     if (RSTRING_LEN(str) <= gz->ungetc) {
-        gz->ungetc -= RSTRING_LEN(str);
+	gz->ungetc -= RSTRING_LEN(str);
     }
     else {
-        gz->crc = checksum_long(crc32, gz->crc, (Bytef*)RSTRING_PTR(str) + gz->ungetc,
-                        RSTRING_LEN(str) - gz->ungetc);
-        gz->ungetc = 0;
+	gz->crc = checksum_long(crc32, gz->crc, (Bytef*)RSTRING_PTR(str) + gz->ungetc,
+			RSTRING_LEN(str) - gz->ungetc);
+	gz->ungetc = 0;
     }
 }
 
@@ -2411,20 +2636,19 @@ static VALUE
 gzfile_newstr(struct gzfile *gz, VALUE str)
 {
     if (!gz->enc2) {
-        rb_enc_associate(str, gz->enc);
-        OBJ_TAINT(str);  /* for safe */
-        return str;
+	rb_enc_associate(str, gz->enc);
+	OBJ_TAINT(str);  /* for safe */
+	return str;
     }
     /* TODO: Encodings
-     *
     if (gz->ec && rb_enc_dummy_p(gz->enc2)) {
         str = rb_econv_str_convert(gz->ec, str, ECONV_PARTIAL_INPUT);
-        rb_enc_associate(str, gz->enc);
-        OBJ_TAINT(str);
-        return str;
+	rb_enc_associate(str, gz->enc);
+	OBJ_TAINT(str);
+	return str;
     }
     return rb_str_conv_enc_opts(str, gz->enc2, gz->enc,
-                                gz->ecflags, gz->ecopts);
+				gz->ecflags, gz->ecopts);
     */
     return str;
 }
@@ -2435,15 +2659,15 @@ gzfile_fill(struct gzfile *gz, long len)
     if (len < 0)
         rb_raise(rb_eArgError, "negative length %ld given", len);
     if (len == 0)
-        return 0;
+	return 0;
     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
-        gzfile_read_more(gz);
+	gzfile_read_more(gz);
     }
     if (GZFILE_IS_FINISHED(gz)) {
-        if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-            gzfile_check_footer(gz);
-        }
-        return -1;
+	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
+	    gzfile_check_footer(gz);
+	}
+	return -1;
     }
     return len < gz->z.buf_filled ? len : gz->z.buf_filled;
 }
@@ -2457,7 +2681,7 @@ gzfile_read(struct gzfile *gz, long len)
     if (len == 0) return rb_str_new(0, 0);
     if (len < 0) return Qnil;
     dst = zstream_shift_buffer(&gz->z, len);
-    gzfile_calc_crc(gz, dst);
+    if (!NIL_P(dst)) gzfile_calc_crc(gz, dst);
     return dst;
 }
 
@@ -2470,7 +2694,7 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
         rb_raise(rb_eArgError, "negative length %ld given", len);
 
     if (!NIL_P(outbuf))
-        OBJ_TAINT(outbuf);
+	OBJ_TAINT(outbuf);
 
     if (len == 0) {
         if (NIL_P(outbuf))
@@ -2481,15 +2705,15 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
         }
     }
     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled == 0) {
-        gzfile_read_more(gz);
+	gzfile_read_more(gz);
     }
     if (GZFILE_IS_FINISHED(gz)) {
-        if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-            gzfile_check_footer(gz);
-        }
+	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
+	    gzfile_check_footer(gz);
+	}
         if (!NIL_P(outbuf))
             rb_str_resize(outbuf, 0);
-        rb_raise(rb_eEOFError, "end of file reached");
+	rb_raise(rb_eEOFError, "end of file reached");
     }
 
     dst = zstream_shift_buffer(&gz->z, len);
@@ -2498,7 +2722,7 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
     if (!NIL_P(outbuf)) {
         rb_str_resize(outbuf, RSTRING_LEN(dst));
         memcpy(RSTRING_PTR(outbuf), RSTRING_PTR(dst), RSTRING_LEN(dst));
-        dst = outbuf;
+	dst = outbuf;
     }
     OBJ_TAINT(dst);  /* for safe */
     return dst;
@@ -2510,16 +2734,17 @@ gzfile_read_all(struct gzfile *gz)
     VALUE dst;
 
     while (!ZSTREAM_IS_FINISHED(&gz->z)) {
-        gzfile_read_more(gz);
+	gzfile_read_more(gz);
     }
     if (GZFILE_IS_FINISHED(gz)) {
-        if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-            gzfile_check_footer(gz);
-        }
-        return rb_str_new(0, 0);
+	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
+	    gzfile_check_footer(gz);
+	}
+	return rb_str_new(0, 0);
     }
 
     dst = zstream_detach_buffer(&gz->z);
+    if (NIL_P(dst)) return dst;
     gzfile_calc_crc(gz, dst);
     OBJ_TAINT(dst);
     return gzfile_newstr(gz, dst);
@@ -2533,47 +2758,46 @@ gzfile_getc(struct gzfile *gz)
 
     len = rb_enc_mbmaxlen(gz->enc);
     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
-        gzfile_read_more(gz);
+	gzfile_read_more(gz);
     }
     if (GZFILE_IS_FINISHED(gz)) {
-        if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-            gzfile_check_footer(gz);
-        }
-        return Qnil;
+	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
+	    gzfile_check_footer(gz);
+	}
+	return Qnil;
     }
 
     /* TODO: Encodings
-     *
     if (gz->ec && rb_enc_dummy_p(gz->enc2)) {
-        const unsigned char *ss, *sp, *se;
-        unsigned char *ds, *dp, *de;
-        rb_econv_result_t res;
+	const unsigned char *ss, *sp, *se;
+	unsigned char *ds, *dp, *de;
 
-        if (!gz->cbuf) {
-            gz->cbuf = ALLOC_N(char, GZFILE_CBUF_CAPA);
-        }
+	if (!gz->cbuf) {
+	    gz->cbuf = ALLOC_N(char, GZFILE_CBUF_CAPA);
+	}
         ss = sp = (const unsigned char*)RSTRING_PTR(gz->z.buf);
         se = sp + gz->z.buf_filled;
         ds = dp = (unsigned char *)gz->cbuf;
         de = (unsigned char *)ds + GZFILE_CBUF_CAPA;
-        res = rb_econv_convert(gz->ec, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_AFTER_OUTPUT);
+        (void)rb_econv_convert(gz->ec, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_AFTER_OUTPUT);
         rb_econv_check_error(gz->ec);
-        dst = zstream_shift_buffer(&gz->z, sp - ss);
-        gzfile_calc_crc(gz, dst);
-        dst = rb_str_new(gz->cbuf, dp - ds);
-        rb_enc_associate(dst, gz->enc);
-        OBJ_TAINT(dst);
-        return dst;
+	dst = zstream_shift_buffer(&gz->z, sp - ss);
+	gzfile_calc_crc(gz, dst);
+	dst = rb_str_new(gz->cbuf, dp - ds);
+	rb_enc_associate(dst, gz->enc);
+	OBJ_TAINT(dst);
+	return dst;
     }
     else {
     */
-        buf = gz->z.buf;
-        len = rb_enc_mbclen(RSTRING_PTR(buf), RSTRING_END(buf), gz->enc);
-        dst = gzfile_read(gz, len);
-        return gzfile_newstr(gz, dst);
-    /* TODO: Encodings
+	buf = gz->z.buf;
+	len = rb_enc_mbclen(RSTRING_PTR(buf), RSTRING_END(buf), gz->enc);
+	dst = gzfile_read(gz, len);
+	if (NIL_P(dst)) return dst;
+	return gzfile_newstr(gz, dst);
+  /* TODO: Encodings
     }
-    */
+  */
 }
 
 static void
@@ -2596,7 +2820,7 @@ gzfile_writer_end_run(VALUE arg)
     struct gzfile *gz = (struct gzfile *)arg;
 
     if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
-        gzfile_make_header(gz);
+	gzfile_make_header(gz);
     }
 
     zstream_run(&gz->z, (Bytef*)"", 0, Z_FINISH);
@@ -2621,8 +2845,8 @@ gzfile_reader_end_run(VALUE arg)
     struct gzfile *gz = (struct gzfile *)arg;
 
     if (GZFILE_IS_FINISHED(gz)
-        && !(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-        gzfile_check_footer(gz);
+	&& !(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
+	gzfile_check_footer(gz);
     }
 
     return Qnil;
@@ -2644,7 +2868,7 @@ gzfile_reader_rewind(struct gzfile *gz)
 
     n = gz->z.stream.total_in;
     if (!NIL_P(gz->z.input)) {
-        n += RSTRING_LEN(gz->z.input);
+	n += RSTRING_LEN(gz->z.input);
     }
 
     rb_funcall(gz->io, id_seek, 2, rb_int2inum(-n), INT2FIX(1));
@@ -2659,11 +2883,11 @@ gzfile_reader_get_unused(struct gzfile *gz)
     if (!ZSTREAM_IS_READY(&gz->z)) return Qnil;
     if (!GZFILE_IS_FINISHED(gz)) return Qnil;
     if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-        gzfile_check_footer(gz);
+	gzfile_check_footer(gz);
     }
     if (NIL_P(gz->z.input)) return Qnil;
 
-    str = rb_str_dup(gz->z.input);
+    str = rb_str_resurrect(gz->z.input);
     OBJ_TAINT(str);  /* for safe */
     return str;
 }
@@ -2675,7 +2899,7 @@ get_gzfile(VALUE obj)
 
     Data_Get_Struct(obj, struct gzfile, gz);
     if (!ZSTREAM_IS_READY(&gz->z)) {
-        rb_raise(cGzError, "closed gzip stream");
+	rb_raise(cGzError, "closed gzip stream");
     }
     return gz;
 }
@@ -2741,7 +2965,7 @@ gzfile_ensure_close(VALUE obj)
 
     Data_Get_Struct(obj, struct gzfile, gz);
     if (ZSTREAM_IS_READY(&gz->z)) {
-        gzfile_close(gz, 1);
+	gzfile_close(gz, 1);
     }
     return Qnil;
 }
@@ -2752,40 +2976,43 @@ gzfile_wrap(int argc, VALUE *argv, VALUE klass, int close_io_on_error)
     VALUE obj;
 
     if (close_io_on_error) {
-        int state = 0;
-        new_wrap_arg_t arg;
-        arg.argc = argc;
-        arg.argv = argv;
-        arg.klass = klass;
-        obj = rb_protect(new_wrap, (VALUE)&arg, &state);
-        if (state) {
-            rb_io_close(argv[0]);
-            rb_jump_tag(state);
-        }
+	int state = 0;
+	new_wrap_arg_t arg;
+	arg.argc = argc;
+	arg.argv = argv;
+	arg.klass = klass;
+	obj = rb_protect(new_wrap, (VALUE)&arg, &state);
+	if (state) {
+	    rb_io_close(argv[0]);
+	    rb_jump_tag(state);
+	}
     }
     else {
-        obj = rb_class_new_instance(argc, argv, klass);
+	obj = rb_class_new_instance(argc, argv, klass);
     }
 
     if (rb_block_given_p()) {
-        return rb_ensure(rb_yield, obj, gzfile_ensure_close, obj);
+	return rb_ensure(rb_yield, obj, gzfile_ensure_close, obj);
     }
     else {
-        return obj;
+	return obj;
     }
 }
 
 /*
  * Document-method: Zlib::GzipFile.wrap
  *
- * call-seq: Zlib::GzipFile.wrap(io) { |gz| ... }
+ * call-seq:
+ *   Zlib::GzipReader.wrap(io, ...) { |gz| ... }
+ *   Zlib::GzipWriter.wrap(io, ...) { |gz| ... }
  *
- * Creates a GzipFile object associated with +io+, and
- * executes the block with the newly created GzipFile object,
- * just like File.open. The GzipFile object will be closed
- * automatically after executing the block. If you want to keep
- * the associated IO object opening, you may call
- * +Zlib::GzipFile#finish+ method in the block.
+ * Creates a GzipReader or GzipWriter associated with +io+, passing in any
+ * necessary extra options, and executes the block with the newly created
+ * object just like File.open.
+ *
+ * The GzipFile object will be closed automatically after executing the block.
+ * If you want to keep the associated IO object open, you may call
+ * Zlib::GzipFile#finish method in the block.
  */
 static VALUE
 rb_gzfile_s_wrap(int argc, VALUE *argv, VALUE klass)
@@ -2804,7 +3031,7 @@ gzfile_s_open(int argc, VALUE *argv, VALUE klass, const char *mode)
     VALUE io, filename;
 
     if (argc < 1) {
-        rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
+	rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
     }
     filename = argv[0];
     io = rb_file_open_str(filename, mode);
@@ -2878,7 +3105,7 @@ rb_gzfile_orig_name(VALUE obj)
 {
     VALUE str = get_gzfile(obj)->orig_name;
     if (!NIL_P(str)) {
-        str = rb_str_dup(str);
+	str = rb_str_dup(str);
     }
     OBJ_TAINT(str);  /* for safe */
     return str;
@@ -2895,7 +3122,7 @@ rb_gzfile_comment(VALUE obj)
 {
     VALUE str = get_gzfile(obj)->comment;
     if (!NIL_P(str)) {
-        str = rb_str_dup(str);
+	str = rb_str_dup(str);
     }
     OBJ_TAINT(str);  /* for safe */
     return str;
@@ -2938,16 +3165,12 @@ rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
     VALUE val;
 
     if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
-        rb_raise(cGzError, "header is already written");
+	rb_raise(cGzError, "header is already written");
     }
 
-    if (FIXNUM_P(mtime)) {
-        gz->mtime = FIX2INT(mtime);
-    }
-    else {
-        val = rb_Integer(mtime);
-        gz->mtime = FIXNUM_P(val) ? FIX2UINT(val) : rb_big2ulong(val);
-    }
+    val = rb_Integer(mtime);
+    gz->mtime = NUM2UINT(val);
+
     return mtime;
 }
 
@@ -2964,12 +3187,12 @@ rb_gzfile_set_orig_name(VALUE obj, VALUE str)
     char *p;
 
     if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
-        rb_raise(cGzError, "header is already written");
+	rb_raise(cGzError, "header is already written");
     }
     s = rb_str_dup(rb_str_to_str(str));
     p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
     if (p) {
-        rb_str_resize(s, p - RSTRING_PTR(s));
+	rb_str_resize(s, p - RSTRING_PTR(s));
     }
     gz->orig_name = s;
     return str;
@@ -2988,12 +3211,12 @@ rb_gzfile_set_comment(VALUE obj, VALUE str)
     char *p;
 
     if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
-        rb_raise(cGzError, "header is already written");
+	rb_raise(cGzError, "header is already written");
     }
     s = rb_str_dup(rb_str_to_str(str));
     p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
     if (p) {
-        rb_str_resize(s, p - RSTRING_PTR(s));
+	rb_str_resize(s, p - RSTRING_PTR(s));
     }
     gz->comment = s;
     return str;
@@ -3087,10 +3310,10 @@ rb_gzfile_set_sync(VALUE obj, VALUE mode)
     struct gzfile *gz = get_gzfile(obj);
 
     if (RTEST(mode)) {
-        gz->z.flags |= GZFILE_FLAG_SYNC;
+	gz->z.flags |= GZFILE_FLAG_SYNC;
     }
     else {
-        gz->z.flags &= ~GZFILE_FLAG_SYNC;
+	gz->z.flags &= ~GZFILE_FLAG_SYNC;
     }
     return mode;
 }
@@ -3137,18 +3360,17 @@ rb_gzfile_path(VALUE obj)
 static void
 rb_gzfile_ecopts(struct gzfile *gz, VALUE opts)
 {
-    /* TODO: Encodings
-     *
+  /* TODO: Encodings
     if (!NIL_P(opts)) {
-        rb_io_extract_encoding_option(opts, &gz->enc, &gz->enc2, NULL);
+	rb_io_extract_encoding_option(opts, &gz->enc, &gz->enc2, NULL);
     }
     if (gz->enc2) {
-        gz->ecflags = rb_econv_prepare_opts(opts, &opts);
-        gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
-                                    gz->ecflags, opts);
-        gz->ecopts = opts;
+	gz->ecflags = rb_econv_prepare_opts(opts, &opts);
+	gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
+				    gz->ecflags, opts);
+	gz->ecopts = opts;
     }
-    */
+  */
 }
 
 /* ------------------------------------------------------------------------- */
@@ -3206,12 +3428,17 @@ rb_gzwriter_s_open(int argc, VALUE *argv, VALUE klass)
 }
 
 /*
- * call-seq: Zlib::GzipWriter.new(io, level, strategy)
+ * call-seq:
+ *   Zlib::GzipWriter.new(io, level = nil, strategy = nil, options = {})
  *
  * Creates a GzipWriter object associated with +io+. +level+ and +strategy+
  * should be the same as the arguments of Zlib::Deflate.new.  The GzipWriter
- * object writes gzipped data to +io+.  At least, +io+ must respond to the
- * +write+ method that behaves same as write method in IO class.
+ * object writes gzipped data to +io+.  +io+ must respond to the
+ * +write+ method that behaves the same as IO#write.
+ *
+ * The +options+ hash may be used to set the encoding of the data.
+ * +:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
+ * IO::new.
  */
 static VALUE
 rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
@@ -3221,8 +3448,8 @@ rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
     int err;
 
     if (argc > 1) {
-        opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash");
-        if (!NIL_P(opt)) argc--;
+	opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash");
+	if (!NIL_P(opt)) argc--;
     }
 
     rb_scan_args(argc, argv, "12", &io, &level, &strategy);
@@ -3231,17 +3458,17 @@ rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
     /* this is undocumented feature of zlib */
     gz->level = ARG_LEVEL(level);
     err = deflateInit2(&gz->z.stream, gz->level, Z_DEFLATED,
-                       -MAX_WBITS, DEF_MEM_LEVEL, ARG_STRATEGY(strategy));
+		       -MAX_WBITS, DEF_MEM_LEVEL, ARG_STRATEGY(strategy));
     if (err != Z_OK) {
-        raise_zlib_error(err, gz->z.stream.msg);
+	raise_zlib_error(err, gz->z.stream.msg);
     }
     gz->io = io;
     ZSTREAM_READY(&gz->z);
     rb_gzfile_ecopts(gz, opt);
 
     if (rb_respond_to(io, id_path)) {
-        gz->path = rb_funcall(gz->io, id_path, 0);
-        rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
+	gz->path = rb_funcall(gz->io, id_path, 0);
+	rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
     }
 
     return obj;
@@ -3265,12 +3492,12 @@ rb_gzwriter_flush(int argc, VALUE *argv, VALUE obj)
 
     flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
     if (flush != Z_NO_FLUSH) {  /* prevent Z_BUF_ERROR */
-        zstream_run(&gz->z, (Bytef*)"", 0, flush);
+	zstream_run(&gz->z, (Bytef*)"", 0, flush);
     }
 
     gzfile_write_raw(gz);
     if (rb_respond_to(gz->io, id_flush)) {
-        rb_funcall(gz->io, id_flush, 0);
+	rb_funcall(gz->io, id_flush, 0);
     }
     return obj;
 }
@@ -3283,10 +3510,10 @@ rb_gzwriter_write(VALUE obj, VALUE str)
 {
     struct gzfile *gz = get_gzfile(obj);
 
-    if (TYPE(str) != T_STRING)
-        str = rb_obj_as_string(str);
+    if (!RB_TYPE_P(str, T_STRING))
+	str = rb_obj_as_string(str);
     if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
-        str = rb_str_conv_enc(str, rb_enc_get(str), gz->enc2);
+	str = rb_str_conv_enc(str, rb_enc_get(str), gz->enc2);
     }
     gzfile_write(gz, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
     return INT2FIX(RSTRING_LEN(str));
@@ -3335,7 +3562,7 @@ rb_gzwriter_putc(VALUE obj, VALUE ch)
  * Document-class: Zlib::GzipReader
  *
  * Zlib::GzipReader is the class for reading a gzipped file.  GzipReader should
- * be used an IO, or -IO-lie, object.
+ * be used an IO, or -IO-like, object.
  *
  *   Zlib::GzipReader.open('hoge.gz') {|gz|
  *     print gz.read
@@ -3407,11 +3634,16 @@ rb_gzreader_s_open(int argc, VALUE *argv, VALUE klass)
 /*
  * Document-method: Zlib::GzipReader.new
  *
- * call-seq: Zlib::GzipReader.new(io)
+ * call-seq:
+ *   Zlib::GzipReader.new(io, options = {})
  *
  * Creates a GzipReader object associated with +io+. The GzipReader object reads
- * gzipped data from +io+, and parses/decompresses them.  At least, +io+ must have
- * a +read+ method that behaves same as the +read+ method in IO class.
+ * gzipped data from +io+, and parses/decompresses it.  The +io+ must
+ * have a +read+ method that behaves same as the IO#read.
+ *
+ * The +options+ hash may be used to set the encoding of the data.
+ * +:external_encoding+, +:internal_encoding+ and +:encoding+ may be set as in
+ * IO::new.
  *
  * If the gzip file header is incorrect, raises an Zlib::GzipFile::Error
  * exception.
@@ -3429,7 +3661,7 @@ rb_gzreader_initialize(int argc, VALUE *argv, VALUE obj)
     /* this is undocumented feature of zlib */
     err = inflateInit2(&gz->z.stream, -MAX_WBITS);
     if (err != Z_OK) {
-        raise_zlib_error(err, gz->z.stream.msg);
+	raise_zlib_error(err, gz->z.stream.msg);
     }
     gz->io = io;
     ZSTREAM_READY(&gz->z);
@@ -3437,8 +3669,8 @@ rb_gzreader_initialize(int argc, VALUE *argv, VALUE obj)
     rb_gzfile_ecopts(gz, opt);
 
     if (rb_respond_to(io, id_path)) {
-        gz->path = rb_funcall(gz->io, id_path, 0);
-        rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
+	gz->path = rb_funcall(gz->io, id_path, 0);
+	rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
     }
 
     return obj;
@@ -3486,12 +3718,12 @@ rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
 
     rb_scan_args(argc, argv, "01", &vlen);
     if (NIL_P(vlen)) {
-        return gzfile_read_all(gz);
+	return gzfile_read_all(gz);
     }
 
     len = NUM2INT(vlen);
     if (len < 0) {
-        rb_raise(rb_eArgError, "negative length %ld given", len);
+	rb_raise(rb_eArgError, "negative length %ld given", len);
     }
     return gzfile_read(gz, len);
 }
@@ -3519,7 +3751,7 @@ rb_gzreader_readpartial(int argc, VALUE *argv, VALUE obj)
 
     len = NUM2INT(vlen);
     if (len < 0) {
-        rb_raise(rb_eArgError, "negative length %ld given", len);
+	rb_raise(rb_eArgError, "negative length %ld given", len);
     }
     if (!NIL_P(outbuf))
         Check_Type(outbuf, T_STRING);
@@ -3550,7 +3782,7 @@ rb_gzreader_readchar(VALUE obj)
     VALUE dst;
     dst = rb_gzreader_getc(obj);
     if (NIL_P(dst)) {
-        rb_raise(rb_eEOFError, "end of file reached");
+	rb_raise(rb_eEOFError, "end of file reached");
     }
     return dst;
 }
@@ -3568,7 +3800,7 @@ rb_gzreader_getbyte(VALUE obj)
 
     dst = gzfile_read(gz, 1);
     if (!NIL_P(dst)) {
-        dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
+	dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
     }
     return dst;
 }
@@ -3584,7 +3816,7 @@ rb_gzreader_readbyte(VALUE obj)
     VALUE dst;
     dst = rb_gzreader_getbyte(obj);
     if (NIL_P(dst)) {
-        rb_raise(rb_eEOFError, "end of file reached");
+	rb_raise(rb_eEOFError, "end of file reached");
     }
     return dst;
 }
@@ -3602,7 +3834,7 @@ rb_gzreader_each_char(VALUE obj)
     RETURN_ENUMERATOR(obj, 0, 0);
 
     while (!NIL_P(c = rb_gzreader_getc(obj))) {
-        rb_yield(c);
+	rb_yield(c);
     }
     return Qnil;
 }
@@ -3620,11 +3852,25 @@ rb_gzreader_each_byte(VALUE obj)
     RETURN_ENUMERATOR(obj, 0, 0);
 
     while (!NIL_P(c = rb_gzreader_getbyte(obj))) {
-        rb_yield(c);
+	rb_yield(c);
     }
     return Qnil;
 }
 
+/*
+ * Document-method: Zlib::GzipReader#bytes
+ *
+ *  This is a deprecated alias for <code>each_byte</code>.
+ */
+static VALUE
+rb_gzreader_bytes(VALUE obj)
+{
+    rb_warn("Zlib::GzipReader#bytes is deprecated; use #each_byte instead");
+    if (!rb_block_given_p())
+	return rb_enumeratorize(obj, ID2SYM(rb_intern("each_byte")), 0, 0);
+    return rb_gzreader_each_byte(obj);
+}
+
 /*
  * Document-method: Zlib::GzipReader#ungetc
  *
@@ -3636,11 +3882,11 @@ rb_gzreader_ungetc(VALUE obj, VALUE s)
     struct gzfile *gz;
 
     if (FIXNUM_P(s))
-        return rb_gzreader_ungetbyte(obj, s);
+	return rb_gzreader_ungetbyte(obj, s);
     gz = get_gzfile(obj);
     StringValue(s);
     if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
-        s = rb_str_conv_enc(s, rb_enc_get(s), gz->enc2);
+	s = rb_str_conv_enc(s, rb_enc_get(s), gz->enc2);
     }
     gzfile_ungets(gz, (const Bytef*)RSTRING_PTR(s), RSTRING_LEN(s));
     return Qnil;
@@ -3667,23 +3913,23 @@ gzreader_skip_linebreaks(struct gzfile *gz)
     int n;
 
     while (gz->z.buf_filled == 0) {
-        if (GZFILE_IS_FINISHED(gz)) return;
-        gzfile_read_more(gz);
+	if (GZFILE_IS_FINISHED(gz)) return;
+	gzfile_read_more(gz);
     }
     n = 0;
     p = RSTRING_PTR(gz->z.buf);
 
     while (n++, *(p++) == '\n') {
-        if (n >= gz->z.buf_filled) {
-            str = zstream_detach_buffer(&gz->z);
-            gzfile_calc_crc(gz, str);
-            while (gz->z.buf_filled == 0) {
-                if (GZFILE_IS_FINISHED(gz)) return;
-                gzfile_read_more(gz);
-            }
-            n = 0;
-            p = RSTRING_PTR(gz->z.buf);
-        }
+	if (n >= gz->z.buf_filled) {
+	    str = zstream_detach_buffer(&gz->z);
+	    gzfile_calc_crc(gz, str);
+	    while (gz->z.buf_filled == 0) {
+		if (GZFILE_IS_FINISHED(gz)) return;
+		gzfile_read_more(gz);
+	    }
+	    n = 0;
+	    p = RSTRING_PTR(gz->z.buf);
+	}
     }
 
     str = zstream_shift_buffer(&gz->z, n - 1);
@@ -3694,7 +3940,7 @@ static void
 rscheck(const char *rsptr, long rslen, VALUE rs)
 {
     if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
-        rb_raise(rb_eRuntimeError, "rs modified");
+	rb_raise(rb_eRuntimeError, "rs modified");
 }
 
 static long
@@ -3705,15 +3951,15 @@ gzreader_charboundary(struct gzfile *gz, long n)
     char *p = rb_enc_left_char_head(s, s + n, e, gz->enc);
     long l = p - s;
     if (l < n) {
-        n = rb_enc_precise_mbclen(p, e, gz->enc);
-        if (ONIGENC_MBCLEN_NEEDMORE_P(n)) {
-            if ((l = gzfile_fill(gz, l + ONIGENC_MBCLEN_NEEDMORE_LEN(n))) > 0) {
-                return l;
-            }
-        }
-        else if (ONIGENC_MBCLEN_CHARFOUND_P(n)) {
-            return l + ONIGENC_MBCLEN_CHARFOUND_LEN(n);
-        }
+	n = rb_enc_precise_mbclen(p, e, gz->enc);
+	if (MBCLEN_NEEDMORE_P(n)) {
+	    if ((l = gzfile_fill(gz, l + MBCLEN_NEEDMORE_LEN(n))) > 0) {
+		return l;
+	    }
+	}
+	else if (MBCLEN_CHARFOUND_P(n)) {
+	    return l + MBCLEN_CHARFOUND_LEN(n);
+	}
     }
     return n;
 }
@@ -3732,110 +3978,112 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
     int maxlen = rb_enc_mbmaxlen(enc);
 
     if (argc == 0) {
-        rs = rb_rs;
+	rs = rb_rs;
     }
     else {
-        VALUE lim, tmp;
-
-        rb_scan_args(argc, argv, "11", &rs, &lim);
-        if (!NIL_P(lim)) {
-            if (!NIL_P(rs)) StringValue(rs);
-        }
-        else if (!NIL_P(rs)) {
-            tmp = rb_check_string_type(rs);
-            if (NIL_P(tmp)) {
-                lim = rs;
-                rs = rb_rs;
-            }
-            else {
-                rs = tmp;
-            }
-        }
-        if (!NIL_P(lim)) {
-            limit = NUM2LONG(lim);
-            if (limit == 0) return rb_str_new(0,0);
-        }
+	VALUE lim, tmp;
+
+	rb_scan_args(argc, argv, "11", &rs, &lim);
+	if (!NIL_P(lim)) {
+	    if (!NIL_P(rs)) StringValue(rs);
+	}
+	else if (!NIL_P(rs)) {
+	    tmp = rb_check_string_type(rs);
+	    if (NIL_P(tmp)) {
+		lim = rs;
+		rs = rb_rs;
+	    }
+	    else {
+		rs = tmp;
+	    }
+	}
+	if (!NIL_P(lim)) {
+	    limit = NUM2LONG(lim);
+	    if (limit == 0) return rb_str_new(0,0);
+	}
     }
 
     if (NIL_P(rs)) {
-        if (limit < 0) {
-            dst = gzfile_read_all(gz);
-            if (RSTRING_LEN(dst) == 0) return Qnil;
-        }
-        else if ((n = gzfile_fill(gz, limit)) <= 0) {
-            return Qnil;
-        }
-        else {
-            if (maxlen > 1 && n >= limit && !GZFILE_IS_FINISHED(gz)) {
-                n = gzreader_charboundary(gz, n);
-            }
-            else {
-                n = limit;
-            }
-            dst = zstream_shift_buffer(&gz->z, n);
-            gzfile_calc_crc(gz, dst);
-            dst = gzfile_newstr(gz, dst);
-        }
-        gz->lineno++;
-        return dst;
+	if (limit < 0) {
+	    dst = gzfile_read_all(gz);
+	    if (RSTRING_LEN(dst) == 0) return Qnil;
+	}
+	else if ((n = gzfile_fill(gz, limit)) <= 0) {
+	    return Qnil;
+	}
+	else {
+	    if (maxlen > 1 && n >= limit && !GZFILE_IS_FINISHED(gz)) {
+		n = gzreader_charboundary(gz, n);
+	    }
+	    else {
+		n = limit;
+	    }
+	    dst = zstream_shift_buffer(&gz->z, n);
+	    if (NIL_P(dst)) return dst;
+	    gzfile_calc_crc(gz, dst);
+	    dst = gzfile_newstr(gz, dst);
+	}
+	gz->lineno++;
+	return dst;
     }
 
     if (RSTRING_LEN(rs) == 0) {
-        rsptr = "\n\n";
-        rslen = 2;
-        rspara = 1;
+	rsptr = "\n\n";
+	rslen = 2;
+	rspara = 1;
     } else {
-        rsptr = RSTRING_PTR(rs);
-        rslen = RSTRING_LEN(rs);
-        rspara = 0;
+	rsptr = RSTRING_PTR(rs);
+	rslen = RSTRING_LEN(rs);
+	rspara = 0;
     }
 
     if (rspara) {
-        gzreader_skip_linebreaks(gz);
+	gzreader_skip_linebreaks(gz);
     }
 
     while (gz->z.buf_filled < rslen) {
-        if (ZSTREAM_IS_FINISHED(&gz->z)) {
-            if (gz->z.buf_filled > 0) gz->lineno++;
-            return gzfile_read(gz, rslen);
-        }
-        gzfile_read_more(gz);
+	if (ZSTREAM_IS_FINISHED(&gz->z)) {
+	    if (gz->z.buf_filled > 0) gz->lineno++;
+	    return gzfile_read(gz, rslen);
+	}
+	gzfile_read_more(gz);
     }
 
     p = RSTRING_PTR(gz->z.buf);
     n = rslen;
     for (;;) {
-        long filled;
-        if (n > gz->z.buf_filled) {
-            if (ZSTREAM_IS_FINISHED(&gz->z)) break;
-            gzfile_read_more(gz);
-            p = RSTRING_PTR(gz->z.buf) + n - rslen;
-        }
-        if (!rspara) rscheck(rsptr, rslen, rs);
-        filled = gz->z.buf_filled;
-        if (limit > 0 && filled >= limit) {
-            filled = limit;
-        }
-        res = memchr(p, rsptr[0], (filled - n + 1));
-        if (!res) {
-            n = filled;
-            if (limit > 0 && filled >= limit) break;
-            n++;
-        } else {
-            n += (long)(res - p);
-            p = res;
-            if (rslen == 1 || memcmp(p, rsptr, rslen) == 0) break;
-            p++, n++;
-        }
+	long filled;
+	if (n > gz->z.buf_filled) {
+	    if (ZSTREAM_IS_FINISHED(&gz->z)) break;
+	    gzfile_read_more(gz);
+	    p = RSTRING_PTR(gz->z.buf) + n - rslen;
+	}
+	if (!rspara) rscheck(rsptr, rslen, rs);
+	filled = gz->z.buf_filled;
+	if (limit > 0 && filled >= limit) {
+	    filled = limit;
+	}
+	res = memchr(p, rsptr[0], (filled - n + 1));
+	if (!res) {
+	    n = filled;
+	    if (limit > 0 && filled >= limit) break;
+	    n++;
+	} else {
+	    n += (long)(res - p);
+	    p = res;
+	    if (rslen == 1 || memcmp(p, rsptr, rslen) == 0) break;
+	    p++, n++;
+	}
     }
     if (maxlen > 1 && n == limit && (gz->z.buf_filled > n || !ZSTREAM_IS_FINISHED(&gz->z))) {
-        n = gzreader_charboundary(gz, n);
+	n = gzreader_charboundary(gz, n);
     }
 
     gz->lineno++;
     dst = gzfile_read(gz, n);
+    if (NIL_P(dst)) return dst;
     if (rspara) {
-        gzreader_skip_linebreaks(gz);
+	gzreader_skip_linebreaks(gz);
     }
 
     return gzfile_newstr(gz, dst);
@@ -3852,7 +4100,7 @@ rb_gzreader_gets(int argc, VALUE *argv, VALUE obj)
     VALUE dst;
     dst = gzreader_gets(argc, argv, obj);
     if (!NIL_P(dst)) {
-        rb_lastline_set(dst);
+	rb_lastline_set(dst);
     }
     return dst;
 }
@@ -3868,7 +4116,7 @@ rb_gzreader_readline(int argc, VALUE *argv, VALUE obj)
     VALUE dst;
     dst = rb_gzreader_gets(argc, argv, obj);
     if (NIL_P(dst)) {
-        rb_raise(rb_eEOFError, "end of file reached");
+	rb_raise(rb_eEOFError, "end of file reached");
     }
     return dst;
 }
@@ -3886,11 +4134,25 @@ rb_gzreader_each(int argc, VALUE *argv, VALUE obj)
     RETURN_ENUMERATOR(obj, 0, 0);
 
     while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
-        rb_yield(str);
+	rb_yield(str);
     }
     return obj;
 }
 
+/*
+ * Document-method: Zlib::GzipReader#lines
+ *
+ *  This is a deprecated alias for <code>each_line</code>.
+ */
+static VALUE
+rb_gzreader_lines(int argc, VALUE *argv, VALUE obj)
+{
+    rb_warn("Zlib::GzipReader#lines is deprecated; use #each_line instead");
+    if (!rb_block_given_p())
+	return rb_enumeratorize(obj, ID2SYM(rb_intern("each_line")), argc, argv);
+    return rb_gzreader_each(argc, argv, obj);
+}
+
 /*
  * Document-method: Zlib::GzipReader#readlines
  *
@@ -3902,96 +4164,13 @@ rb_gzreader_readlines(int argc, VALUE *argv, VALUE obj)
     VALUE str, dst;
     dst = rb_ary_new();
     while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
-        rb_ary_push(dst, str);
+	rb_ary_push(dst, str);
     }
     return dst;
 }
 
 #endif /* GZIP_SUPPORT */
 
-
-
-/*
- * Document-module: Zlib
- *
- * The Zlib module contains several classes for compressing and decompressing
- * streams, and for working with "gzip" files.
- *
- * == Classes
- *
- * Following are the classes that are most likely to be of interest to the
- * user:
- * Zlib::Inflate
- * Zlib::Deflate
- * Zlib::GzipReader
- * Zlib::GzipWriter
- *
- * There are two important base classes for the classes above: Zlib::ZStream
- * and Zlib::GzipFile.  Everything else is an error class.
- *
- * == Constants
- *
- * Here's a list.
- *
- *   Zlib::VERSION
- *       The Ruby/zlib version string.
- *
- *   Zlib::ZLIB_VERSION
- *       The string which represents the version of zlib.h.
- *
- *   Zlib::BINARY
- *   Zlib::ASCII
- *   Zlib::UNKNOWN
- *       The integers representing data types which Zlib::ZStream#data_type
- *       method returns.
- *
- *   Zlib::NO_COMPRESSION
- *   Zlib::BEST_SPEED
- *   Zlib::BEST_COMPRESSION
- *   Zlib::DEFAULT_COMPRESSION
- *       The integers representing compression levels which are an argument
- *       for Zlib::Deflate.new, Zlib::Deflate#deflate, and so on.
- *
- *   Zlib::FILTERED
- *   Zlib::HUFFMAN_ONLY
- *   Zlib::DEFAULT_STRATEGY
- *       The integers representing compression methods which are an argument
- *       for Zlib::Deflate.new and Zlib::Deflate#params.
- *
- *   Zlib::DEF_MEM_LEVEL
- *   Zlib::MAX_MEM_LEVEL
- *       The integers representing memory levels which are an argument for
- *       Zlib::Deflate.new, Zlib::Deflate#params, and so on.
- *
- *   Zlib::MAX_WBITS
- *       The default value of windowBits which is an argument for
- *       Zlib::Deflate.new and Zlib::Inflate.new.
- *
- *   Zlib::NO_FLUSH
- *   Zlib::SYNC_FLUSH
- *   Zlib::FULL_FLUSH
- *   Zlib::FINISH
- *       The integers to control the output of the deflate stream, which are
- *       an argument for Zlib::Deflate#deflate and so on.
- *
- *   Zlib::OS_CODE
- *   Zlib::OS_MSDOS
- *   Zlib::OS_AMIGA
- *   Zlib::OS_VMS
- *   Zlib::OS_UNIX
- *   Zlib::OS_VMCMS
- *   Zlib::OS_ATARI
- *   Zlib::OS_OS2
- *   Zlib::OS_MACOS
- *   Zlib::OS_ZSYSTEM
- *   Zlib::OS_CPM
- *   Zlib::OS_TOPS20
- *   Zlib::OS_WIN32
- *   Zlib::OS_QDOS
- *   Zlib::OS_RISCOS
- *   Zlib::OS_UNKNOWN
- *       The return values of Zlib::GzipFile#os_code method.
- */
 void
 Init_zlib()
 {
@@ -4002,6 +4181,8 @@ Init_zlib()
 
     mZlib = rb_define_module("Zlib");
 
+    id_dictionaries = rb_intern("@dictionaries");
+
     cZError = rb_define_class_under(mZlib, "Error", rb_eStandardError);
     cStreamEnd    = rb_define_class_under(mZlib, "StreamEnd", cZError);
     cNeedDict     = rb_define_class_under(mZlib, "NeedDict", cZError);
@@ -4043,14 +4224,29 @@ Init_zlib()
     rb_define_method(cZStream, "flush_next_in", rb_zstream_flush_next_in, 0);
     rb_define_method(cZStream, "flush_next_out", rb_zstream_flush_next_out, 0);
 
-    /* Integer representing date types which
-     * ZStream#data_type method returns */
+    /* Represents binary data as guessed by deflate.
+     *
+     * See Zlib::Deflate#data_type. */
     rb_define_const(mZlib, "BINARY", INT2FIX(Z_BINARY));
-    /* Integer representing date types which
-     * ZStream#data_type method returns */
+
+    /* Represents text data as guessed by deflate.
+     *
+     * NOTE: The underlying constant Z_ASCII was deprecated in favor of Z_TEXT
+     * in zlib 1.2.2.  New applications should not use this constant.
+     *
+     * See Zlib::Deflate#data_type. */
     rb_define_const(mZlib, "ASCII", INT2FIX(Z_ASCII));
-    /* Integer representing date types which
-     * ZStream#data_type method returns */
+
+#ifdef Z_TEXT
+    /* Represents text data as guessed by deflate.
+     *
+     * See Zlib::Deflate#data_type. */
+    rb_define_const(mZlib, "TEXT", INT2FIX(Z_TEXT));
+#endif
+
+    /* Represents an unknown data type as guessed by deflate.
+     *
+     * See Zlib::Deflate#data_type. */
     rb_define_const(mZlib, "UNKNOWN", INT2FIX(Z_UNKNOWN));
 
     cDeflate = rb_define_class_under(mZlib, "Deflate", cZStream);
@@ -4070,77 +4266,91 @@ Init_zlib()
     rb_define_singleton_method(mZlib, "inflate", rb_inflate_s_inflate, 1);
     rb_define_alloc_func(cInflate, rb_inflate_s_allocate);
     rb_define_method(cInflate, "initialize", rb_inflate_initialize, -1);
+    rb_define_method(cInflate, "add_dictionary", rb_inflate_add_dictionary, 1);
     rb_define_method(cInflate, "inflate", rb_inflate_inflate, 1);
     rb_define_method(cInflate, "<<", rb_inflate_addstr, 1);
     rb_define_method(cInflate, "sync", rb_inflate_sync, 1);
     rb_define_method(cInflate, "sync_point?", rb_inflate_sync_point_p, 0);
     rb_define_method(cInflate, "set_dictionary", rb_inflate_set_dictionary, 1);
 
-    /* compression level 0
-     *
-     * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
+    /* No compression, passes through data untouched.  Use this for appending
+     * pre-compressed data to a deflate stream.
+     */
     rb_define_const(mZlib, "NO_COMPRESSION", INT2FIX(Z_NO_COMPRESSION));
-    /* compression level 1
-     *
-     * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
+    /* Fastest compression level, but with with lowest space savings. */
     rb_define_const(mZlib, "BEST_SPEED", INT2FIX(Z_BEST_SPEED));
-    /* compression level 9
-     *
-     * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
+    /* Slowest compression level, but with the best space savings. */
     rb_define_const(mZlib, "BEST_COMPRESSION", INT2FIX(Z_BEST_COMPRESSION));
-    /* compression level -1
-     *
-     * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
+    /* Default compression level which is a good trade-off between space and
+     * time
+     */
     rb_define_const(mZlib, "DEFAULT_COMPRESSION",
-                    INT2FIX(Z_DEFAULT_COMPRESSION));
-
-    /* compression method 1
-     *
-     * Which is an argument for Deflate.new and Deflate#params. */
+		    INT2FIX(Z_DEFAULT_COMPRESSION));
+
+    /* Deflate strategy for data produced by a filter (or predictor). The
+     * effect of FILTERED is to force more Huffman codes and less string
+     * matching; it is somewhat intermediate between DEFAULT_STRATEGY and
+     * HUFFMAN_ONLY. Filtered data consists mostly of small values with a
+     * somewhat random distribution.
+     */
     rb_define_const(mZlib, "FILTERED", INT2FIX(Z_FILTERED));
-    /* compression method 2
-     *
-     * Which is an argument for Deflate.new and Deflate#params. */
+
+    /* Deflate strategy which uses Huffman codes only (no string matching). */
     rb_define_const(mZlib, "HUFFMAN_ONLY", INT2FIX(Z_HUFFMAN_ONLY));
-    /* compression method 0
-     *
-     * Which is an argument for Deflate.new and Deflate#params. */
+
+#ifdef Z_RLE
+    /* Deflate compression strategy designed to be almost as fast as
+     * HUFFMAN_ONLY, but give better compression for PNG image data.
+     */
+    rb_define_const(mZlib, "RLE", INT2FIX(Z_RLE));
+#endif
+
+#ifdef Z_FIXED
+    /* Deflate strategy which prevents the use of dynamic Huffman codes,
+     * allowing for a simpler decoder for specialized applications.
+     */
+    rb_define_const(mZlib, "FIXED", INT2FIX(Z_FIXED));
+#endif
+
+    /* Default deflate strategy which is used for normal data. */
     rb_define_const(mZlib, "DEFAULT_STRATEGY", INT2FIX(Z_DEFAULT_STRATEGY));
 
-     /* The default value of windowBits which is an argument for
-      * Deflate.new and Inflate.new.
-      */
+    /* The maximum size of the zlib history buffer.  Note that zlib allows
+     * larger values to enable different inflate modes.  See Zlib::Inflate.new
+     * for details.
+     */
     rb_define_const(mZlib, "MAX_WBITS", INT2FIX(MAX_WBITS));
-    /* Default value is 8
-     *
-     * The integer representing memory levels.
-     * Which are an argument for Deflate.new, Deflate#params, and so on. */
+
+    /* The default memory level for allocating zlib deflate compression state.
+     */
     rb_define_const(mZlib, "DEF_MEM_LEVEL", INT2FIX(DEF_MEM_LEVEL));
-    /* Maximum level is 9
-     *
-     * The integers representing memory levels which are an argument for
-     * Deflate.new, Deflate#params, and so on. */
+
+    /* The maximum memory level for allocating zlib deflate compression state.
+     */
     rb_define_const(mZlib, "MAX_MEM_LEVEL", INT2FIX(MAX_MEM_LEVEL));
 
-    /* Output control - 0
-     *
-     * The integers to control the output of the deflate stream, which are
-     * an argument for Deflate#deflate and so on. */
+    /* NO_FLUSH is the default flush method and allows deflate to decide how
+     * much data to accumulate before producing output in order to maximize
+     * compression.
+     */
     rb_define_const(mZlib, "NO_FLUSH", INT2FIX(Z_NO_FLUSH));
-    /* Output control - 2
-     *
-     * The integers to control the output of the deflate stream, which are
-     * an argument for Deflate#deflate and so on. */
+
+    /* The SYNC_FLUSH method flushes all pending output to the output buffer
+     * and the output is aligned on a byte boundary. Flushing may degrade
+     * compression so it should be used only when necessary, such as at a
+     * request or response boundary for a network stream.
+     */
     rb_define_const(mZlib, "SYNC_FLUSH", INT2FIX(Z_SYNC_FLUSH));
-    /* Output control - 3
-     *
-     * The integers to control the output of the deflate stream, which are
-     * an argument for Deflate#deflate and so on. */
+
+    /* Flushes all output as with SYNC_FLUSH, and the compression state is
+     * reset so that decompression can restart from this point if previous
+     * compressed data has been damaged or if random access is desired. Like
+     * SYNC_FLUSH, using FULL_FLUSH too often can seriously degrade
+     * compression.
+     */
     rb_define_const(mZlib, "FULL_FLUSH", INT2FIX(Z_FULL_FLUSH));
-    /* Oputput control - 4
-     *
-     * The integers to control the output of the deflate stream, which are
-     * an argument for Deflate#deflate and so on. */
+
+    /* Processes all pending input and flushes pending output. */
     rb_define_const(mZlib, "FINISH", INT2FIX(Z_FINISH));
 
 #if GZIP_SUPPORT
@@ -4218,48 +4428,47 @@ Init_zlib()
     rb_define_method(cGzipReader, "readbyte", rb_gzreader_readbyte, 0);
     rb_define_method(cGzipReader, "each_byte", rb_gzreader_each_byte, 0);
     rb_define_method(cGzipReader, "each_char", rb_gzreader_each_char, 0);
-    rb_define_method(cGzipReader, "bytes", rb_gzreader_each_byte, 0);
+    rb_define_method(cGzipReader, "bytes", rb_gzreader_bytes, 0);
     rb_define_method(cGzipReader, "ungetc", rb_gzreader_ungetc, 1);
     rb_define_method(cGzipReader, "ungetbyte", rb_gzreader_ungetbyte, 1);
     rb_define_method(cGzipReader, "gets", rb_gzreader_gets, -1);
     rb_define_method(cGzipReader, "readline", rb_gzreader_readline, -1);
     rb_define_method(cGzipReader, "each", rb_gzreader_each, -1);
     rb_define_method(cGzipReader, "each_line", rb_gzreader_each, -1);
-    rb_define_method(cGzipReader, "lines", rb_gzreader_each, -1);
+    rb_define_method(cGzipReader, "lines", rb_gzreader_lines, -1);
     rb_define_method(cGzipReader, "readlines", rb_gzreader_readlines, -1);
 
-    /* From GzipFile#os_code - code of current host */
+    /* The OS code of current host */
     rb_define_const(mZlib, "OS_CODE", INT2FIX(OS_CODE));
-    /* From GzipFile#os_code - 0x00 */
+    /* OS code for MSDOS hosts */
     rb_define_const(mZlib, "OS_MSDOS", INT2FIX(OS_MSDOS));
-    /* From GzipFile#os_code - 0x01 */
+    /* OS code for Amiga hosts */
     rb_define_const(mZlib, "OS_AMIGA", INT2FIX(OS_AMIGA));
-    /* From GzipFile#os_code - 0x02 */
+    /* OS code for VMS hosts */
     rb_define_const(mZlib, "OS_VMS", INT2FIX(OS_VMS));
-    /* From GzipFile#os_code - 0x03 */
+    /* OS code for UNIX hosts */
     rb_define_const(mZlib, "OS_UNIX", INT2FIX(OS_UNIX));
-    /* From GzipFile#os_code - 0x05 */
+    /* OS code for Atari hosts */
     rb_define_const(mZlib, "OS_ATARI", INT2FIX(OS_ATARI));
-    /* From GzipFile#os_code - 0x06 */
+    /* OS code for OS2 hosts */
     rb_define_const(mZlib, "OS_OS2", INT2FIX(OS_OS2));
-    /* From GzipFile#os_code - 0x07 */
+    /* OS code for Mac OS hosts */
     rb_define_const(mZlib, "OS_MACOS", INT2FIX(OS_MACOS));
-    /* From GzipFile#os_code - 0x0a */
+    /* OS code for TOPS-20 hosts */
     rb_define_const(mZlib, "OS_TOPS20", INT2FIX(OS_TOPS20));
-    /* From GzipFile#os_code - 0x0b */
+    /* OS code for Win32 hosts */
     rb_define_const(mZlib, "OS_WIN32", INT2FIX(OS_WIN32));
-
-    /* From GzipFile#os_code - 0x04 */
+    /* OS code for VM OS hosts */
     rb_define_const(mZlib, "OS_VMCMS", INT2FIX(OS_VMCMS));
-    /* From GzipFile#os_code - 0x08 */
+    /* OS code for Z-System hosts */
     rb_define_const(mZlib, "OS_ZSYSTEM", INT2FIX(OS_ZSYSTEM));
-    /* From GzipFile#os_code - 0x09 */
+    /* OS code for CP/M hosts */
     rb_define_const(mZlib, "OS_CPM", INT2FIX(OS_CPM));
-    /* From GzipFile#os_code - 0x0c */
+    /* OS code for QDOS hosts */
     rb_define_const(mZlib, "OS_QDOS", INT2FIX(OS_QDOS));
-    /* From GzipFile#os_code - 0x0d */
+    /* OS code for RISC OS hosts */
     rb_define_const(mZlib, "OS_RISCOS", INT2FIX(OS_RISCOS));
-    /* From GzipFile#os_code - 0xff */
+    /* OS code for unknown hosts */
     rb_define_const(mZlib, "OS_UNKNOWN", INT2FIX(OS_UNKNOWN));
 
 #endif /* GZIP_SUPPORT */