pr-zlib 1.0.0 → 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 942c045dcb34136c2bbf3b77d92f77735482350d
+  data.tar.gz: 0c2682879c45ee2f5aee7dce9d5fde4b20a00402
+SHA512:
+  metadata.gz: 231ab3d027b37a370fc865d304f2f5a6d6779c829829d3c1d73ad65f635505aba3c7b6a436c8b7acd67f674645f5538ee23daf7e8d33472f4d89e31dc2c14102
+  data.tar.gz: adebebe6431c37c4705f7a94c86c2b67578a53a9885ab314001c07f2b7f18eecbd9829e9ddb35e9051a8610da15067d2a5c3af99e59ba91fb8d88b3897f73f9a

data/CHANGES

@@ -1,2 +1,10 @@
+= 1.0.1 - 16-Oct-2014
+* Added benchmark and profiler scripts and rake tasks.
+* Switched profiling scripts to use ruby-prof.
+* The test-unit and ruby-prof libraries are now development dependencies.
+* Minor updates to eliminate warnings for Ruby 1.9.3 and 2.1.
+* Some minor test suite updates, mostly for 1.9.3.
+* Updated the gemspec, removed Rubyforge references.
+
 = 1.0.0 - 12-Jun-2009
 * Initial release

data/Rakefile

@@ -1,88 +1,119 @@
 require 'rake'
+require 'rake/clean'
 require 'rake/testtask'
 require 'rbconfig'
 
-desc 'Install the pr-zlib library'
-task :install do
-   install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
-   Dir.mkdir(install_dir) unless File.exists?(install_dir)
-   files = ['lib/pr/zlib.rb', 'lib/pr/rbzlib.rb']
-   files.each{ |file|
-      FileUtils.cp(file, install_dir, :verbose => true)
-   }
-end
+CLEAN.include("**/*.rbc", "**/*.gem", "**/*.txt", "**/*.gz")
 
 desc 'Install the pr-zlib library as zlib'
 task :install_as_zlib do
-   install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
-   Dir.mkdir(install_dir) unless File.exists?(install_dir)
+  install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
+  Dir.mkdir(install_dir) unless File.exists?(install_dir)
 
-   FileUtils.cp('lib/pr/zlib.rb', Config::CONFIG['sitelibdir'], :verbose => true)
-   FileUtils.cp('lib/pr/rbzlib.rb', install_dir, :verbose => true)
+  cp('lib/pr/zlib.rb', Config::CONFIG['sitelibdir'], :verbose => true)
+  cp('lib/pr/rbzlib.rb', install_dir, :verbose => true)
 end
 
-desc 'Install the pr-zlib library as a gem'
-task :install_gem do
-   ruby 'pr-zlib.gemspec'
-   file = Dir["*.gem"].first
-   sh "gem install #{file}"
+namespace :gem do
+  desc 'Create the pr-zlib gem'
+  task :create do
+    spec = eval(IO.read('pr-zlib.gemspec'))
+    if Gem::VERSION < "2.0"
+      Gem::Builder.new(spec).build
+    else
+      require 'rubygems/package'
+      Gem::Package.build(spec)
+    end
+  end
+
+  desc 'Install the pr-zlib gem'
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install -l #{file}"
+  end
+end
+
+namespace :bench do
+  desc "Run the zlib benchmark"
+  task :zlib do
+    Dir.chdir('profile'){ ruby "bench_zlib.rb" }
+  end
+
+  desc "Run the pr-zlib benchmark"
+  task :przlib do
+    sh "ruby -Ilib profile/bench_pr_zlib.rb"
+  end
+end
+
+namespace :profile do
+  desc "Run the profiler on the write operation"
+  task :write do
+    sh "ruby -Ilib profile/profile_pr_zlib_write.rb"
+  end
+
+  desc "Run the profiler on the read operation"
+  task :read do
+    sh "ruby -Ilib profile/profile_pr_zlib_read.rb"
+  end
 end
 
 Rake::TestTask.new do |t|
-   t.warning = true
-   t.verbose = true   
+  t.warning = true
+  t.verbose = true
 end
 
 Rake::TestTask.new('test_zlib') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_zlib.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_zlib.rb']
 end
 
 Rake::TestTask.new('test_gzip_file') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_zlib_gzip_file.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_zlib_gzip_file.rb']
 end
 
 Rake::TestTask.new('test_gzip_reader') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_zlib_gzip_reader.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_zlib_gzip_reader.rb']
 end
 
 Rake::TestTask.new('test_gzip_writer') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_zlib_gzip_writer.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_zlib_gzip_writer.rb']
 end
 
 Rake::TestTask.new('test_deflate') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_zlib_deflate.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_zlib_deflate.rb']
 end
 
 Rake::TestTask.new('test_inflate') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_zlib_inflate.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_zlib_inflate.rb']
 end
 
 Rake::TestTask.new('test_rbzlib') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_rbzlib.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_rbzlib.rb']
 end
 
 Rake::TestTask.new('test_rbzlib_bytef') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_rbzlib_bytef.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_rbzlib_bytef.rb']
 end
 
 Rake::TestTask.new('test_rbzlib_posf') do |t|
-   t.warning = true
-   t.verbose = true
-   t.test_files = FileList['test/test_rbzlib_posf.rb']
+  t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/test_rbzlib_posf.rb']
 end
+
+task :default => :test

data/lib/pr/rbzlib.rb

@@ -31,927 +31,920 @@
 #
 
 class Fixnum
-   def ord
-      self
-   end
+  def ord
+    self
+  end
 end
 
 module Rbzlib
+  MAX_MEM_LEVEL = 9
+  DEF_MEM_LEVEL = 8
+  MAX_WBITS     = 15
+  DEF_WBITS     = MAX_WBITS
+
+  Z_stream = Struct.new(
+    :next_in,
+    :avail_in,
+    :total_in,
+    :next_out,
+    :avail_out,
+    :total_out,
+    :msg,
+    :state,
+    :data_type,
+    :adler,
+    :reserved
+  )
+
+  Gz_header = Struct.new(
+    :text,
+    :time,
+    :xflags,
+    :os,
+    :extra,
+    :extra_len,
+    :extra_max,
+    :name,
+    :name_max,
+    :comment,
+    :comm_max,
+    :hcrc,
+    :done
+  )
+
+  Z_NO_FLUSH      = 0
+  Z_PARTIAL_FLUSH = 1
+  Z_SYNC_FLUSH    = 2
+  Z_FULL_FLUSH    = 3
+  Z_FINISH        = 4
+  Z_BLOCK         = 5
+
+  Z_OK            = 0
+  Z_STREAM_END    = 1
+  Z_NEED_DICT     = 2
+  Z_ERRNO         = (-1)
+  Z_STREAM_ERROR  = (-2)
+  Z_DATA_ERROR    = (-3)
+  Z_MEM_ERROR     = (-4)
+  Z_BUF_ERROR     = (-5)
+  Z_VERSION_ERROR = (-6)
+
+  Z_NO_COMPRESSION      = 0
+  Z_BEST_SPEED          = 1
+  Z_BEST_COMPRESSION    = 9
+  Z_DEFAULT_COMPRESSION = (-1)
+
+  Z_FILTERED         = 1
+  Z_HUFFMAN_ONLY     = 2
+  Z_RLE              = 3
+  Z_FIXED            = 4
+  Z_DEFAULT_STRATEGY = 0
+
+  Z_BINARY   = 0
+  Z_ASCII    = 1
+  Z_TEXT     = 1
+  Z_UNKNOWN  = 2
+
+  Z_DEFLATED   = 8
+
+  STORED_BLOCK = 0
+  STATIC_TREES = 1
+  DYN_TREES    = 2
+
+  MIN_MATCH   = 3
+  MAX_MATCH   = 258
+  PRESET_DICT = 0x20
+
+  ZLIB_VERSION = '1.2.3'
+
+  Z_errbase = Z_NEED_DICT
+
+  @@z_errmsg = [
+    'need dictionary',
+    'stream end',
+    '',
+    'file error',
+    'stream error',
+    'data error',
+    'insufficient memory',
+    'buffer error',
+    'incompatible version',
+    ''
+  ]
+
+  @@z_verbose = 1
+
+  def zError(err)
+    @@z_errmsg[Z_NEED_DICT - err]
+  end
 
-   MAX_MEM_LEVEL = 9
-   DEF_MEM_LEVEL = 8
-   MAX_WBITS     = 15
-   DEF_WBITS     = MAX_WBITS
-
-   Z_stream = Struct.new(
-      :next_in,
-      :avail_in,
-      :total_in,
-      :next_out,
-      :avail_out,
-      :total_out,
-      :msg,
-      :state,
-      :data_type,
-      :adler,
-      :reserved
-   )
-
-   Gz_header = Struct.new(
-      :text,
-      :time,
-      :xflags,
-      :os,
-      :extra,
-      :extra_len,
-      :extra_max,
-      :name,
-      :name_max,
-      :comment,
-      :comm_max,
-      :hcrc,
-      :done
-   )
-
-   Z_NO_FLUSH      = 0
-   Z_PARTIAL_FLUSH = 1
-   Z_SYNC_FLUSH    = 2
-   Z_FULL_FLUSH    = 3
-   Z_FINISH        = 4
-   Z_BLOCK         = 5
-
-   Z_OK            = 0
-   Z_STREAM_END    = 1
-   Z_NEED_DICT     = 2
-   Z_ERRNO         = (-1)
-   Z_STREAM_ERROR  = (-2)
-   Z_DATA_ERROR    = (-3)
-   Z_MEM_ERROR     = (-4)
-   Z_BUF_ERROR     = (-5)
-   Z_VERSION_ERROR = (-6)
-
-   Z_NO_COMPRESSION      = 0
-   Z_BEST_SPEED          = 1
-   Z_BEST_COMPRESSION    = 9
-   Z_DEFAULT_COMPRESSION = (-1)
-
-   Z_FILTERED         = 1
-   Z_HUFFMAN_ONLY     = 2
-   Z_RLE              = 3
-   Z_FIXED            = 4
-   Z_DEFAULT_STRATEGY = 0
-
-   Z_BINARY   = 0
-   Z_ASCII    = 1
-   Z_TEXT     = 1
-   Z_UNKNOWN  = 2
-
-   Z_DEFLATED   = 8
-
-   STORED_BLOCK = 0
-   STATIC_TREES = 1
-   DYN_TREES    = 2
-
-   MIN_MATCH   = 3
-   MAX_MATCH   = 258
-   PRESET_DICT = 0x20
-
-   ZLIB_VERSION = '1.2.3'
-
-   Z_errbase = Z_NEED_DICT
-
-   @@z_errmsg = [
-      'need dictionary',
-      'stream end',
-      '',
-      'file error',
-      'stream error',
-      'data error',
-      'insufficient memory',
-      'buffer error',
-      'incompatible version',
-      ''
-   ]
-
-   @@z_verbose = 1
-
-   def zError(err)
-      @@z_errmsg[Z_NEED_DICT - err]
-   end
-
-   def zlibVersion()
-      ZLIB_VERSION
-   end
+  def zlibVersion
+    ZLIB_VERSION
+  end
 
-   def z_error(m)
-      raise(RuntimeError,m)
-   end
+  def z_error(m)
+    raise RuntimeError, m
+  end
 
-   class Bytef
-      attr_accessor :buffer, :offset
+  class Bytef
+    attr_accessor :buffer, :offset
 
-      def initialize(buffer, offset=0)
-         if [String, Array].include?(buffer.class)
-            @buffer = buffer
-            @offset = offset
-         else
-            @buffer = buffer.buffer
-            @offset = offset
-         end
+    def initialize(buffer, offset=0)
+      if [String, Array].include?(buffer.class)
+        @buffer = buffer
+        @offset = offset
+      else
+        @buffer = buffer.buffer
+        @offset = offset
       end
+    end
 
-      def length
-         @buffer.length
-      end
+    def length
+      @buffer.length
+    end
 
-      def +(inc)
-         @offset += inc
-         self
-      end
+    def +(inc)
+      @offset += inc
+      self
+    end
 
-      def -(dec)
-         @offset -= dec
-         self
-      end
+    def -(dec)
+      @offset -= dec
+      self
+    end
 
-      def [](idx)
-         if @buffer.is_a?(String)
-            @buffer[idx + @offset].ord
-         else
-            @buffer[idx + @offset]
-         end
+    def [](idx)
+      if @buffer.is_a?(String)
+        @buffer[idx + @offset].ord
+      else
+        @buffer[idx + @offset]
       end
+    end
 
-      def []=(idx, val)
-         if @buffer.is_a?(String) && val.is_a?(Fixnum)
-            @buffer[idx + @offset] = val.chr
-         else
-            @buffer[idx + @offset] = val
-         end
+    def []=(idx, val)
+      if @buffer.is_a?(String) && val.is_a?(Fixnum)
+        @buffer[idx + @offset] = val.chr
+      else
+        @buffer[idx + @offset] = val
       end
+    end
 
-      def get()
-         if @buffer.is_a?(String)
-            @buffer[@offset].ord
-         else
-            @buffer[@offset]
-         end
+    def get()
+      if @buffer.is_a?(String)
+        @buffer[@offset].ord
+      else
+        @buffer[@offset]
       end
+    end
 
-      def set(val)
-         if @buffer.is_a?(String) && val.is_a?(Fixnum)
-            @buffer[@offset] = val.chr
-         else
-            @buffer[@offset] = val
-         end
+    def set(val)
+      if @buffer.is_a?(String) && val.is_a?(Fixnum)
+        @buffer[@offset] = val.chr
+      else
+        @buffer[@offset] = val
       end
+    end
 
-      def current
-         @buffer[@offset..-1]
-      end
-   end
+    def current
+      @buffer[@offset..-1]
+    end
+  end
 
-   class Posf < Bytef
-      def +(inc)
-         @offset += inc * 2
-         self
-      end
+  class Posf < Bytef
+    def +(inc)
+      @offset += inc * 2
+      self
+    end
 
-      def -(dec)
-         @offset -= dec * 2
-         self
-      end
+    def -(dec)
+      @offset -= dec * 2
+      self
+    end
 
-      def [](idx)
-         @buffer[(idx * 2) + @offset, 2].unpack('S').first
-      end
+    def [](idx)
+      @buffer[(idx * 2) + @offset, 2].unpack('S').first
+    end
 
-      def []=(idx, val)
-         @buffer[(idx * 2) + @offset, 2] = [val].pack('S')
-      end
+    def []=(idx, val)
+      @buffer[(idx * 2) + @offset, 2] = [val].pack('S')
+    end
 
-      def get()
-         @buffer[@offset, 2].unpack('S').first
-      end
+    def get()
+      @buffer[@offset, 2].unpack('S').first
+    end
 
-      def set(val)
-         @buffer[@offset, 2] = [val].pack('S')
-      end
-   end
+    def set(val)
+      @buffer[@offset, 2] = [val].pack('S')
+    end
+  end
 
-   BASE = 65521
-   NMAX = 5552
+  BASE = 65521
+  NMAX = 5552
 
-   module_function
+  module_function
 
-   #  compute the Adler-32 checksum of a data stream
-   def adler32(adler, buf, len=0)
-      return 1 if buf.nil?
+  # Compute the Adler-32 checksum of a data stream
+  def adler32(adler, buf, len=0)
+    return 1 if buf.nil?
 
-      len = buf.length if len.zero?
-      sum2 = (adler >> 16) & 0xFFFF
-      adler &= 0xffff
+    len = buf.length if len.zero?
+    sum2 = (adler >> 16) & 0xFFFF
+    adler &= 0xffff
 
-      if len == 1
-         adler += buf[0].ord
-         if adler >= BASE
-            adler -= BASE
-         end
+    if len == 1
+      adler += buf[0].ord
 
-         sum2 += adler
+      if adler >= BASE
+        adler -= BASE
+      end
 
-         if sum2 >= BASE
-            sum2 -= BASE
-         end
+      sum2 += adler
 
-         return adler | (sum2 << 16)
+      if sum2 >= BASE
+        sum2 -= BASE
       end
 
-      if len < 16
-         i = 0
-
-         while len > 0
-            len -= 1
-            adler += buf[i].ord
-            i += 1
-            sum2 += adler
-         end
+      return adler | (sum2 << 16)
+    end
 
-         if adler >= BASE
-            adler -= BASE
-         end
+    if len < 16
+      i = 0
 
-         sum2 %= BASE
+      while len > 0
+        len -= 1
+        adler += buf[i].ord
+        i += 1
+        sum2 += adler
+      end
 
-         return adler | (sum2 << 16)
+      if adler >= BASE
+        adler -= BASE
       end
 
-      i = 0
+      sum2 %= BASE
 
-      while len >= NMAX
-         len -= NMAX
-         n = NMAX / 16
+      return adler | (sum2 << 16)
+    end
 
-         loop do
-            for j in 0 .. 15
-               adler += buf[i+j].ord
-               sum2 += adler
-            end
-            i += 16
-            n -= 1
-            break if n.zero?
-         end
-         adler %= BASE
-         sum2 %= BASE
-      end
+    i = 0
 
-      if len.nonzero?
-        while (len >= 16)
-          len -= 16
-          for j in 0 .. 15
-            adler += buf[i+j].ord
-            sum2 += adler
-          end
-          i += 16
+    while len >= NMAX
+      len -= NMAX
+      n = NMAX / 16
+
+      loop do
+        for j in 0 .. 15
+          adler += buf[i+j].ord
+          sum2 += adler
         end
-        while len.nonzero?
-          len -= 1
-          adler += buf[i].ord
-          i += 1
+        i += 16
+        n -= 1
+        break if n.zero?
+      end
+      adler %= BASE
+      sum2 %= BASE
+    end
+
+    if len.nonzero?
+      while (len >= 16)
+        len -= 16
+        for j in 0 .. 15
+          adler += buf[i+j].ord
           sum2 += adler
         end
-        adler %= BASE
-        sum2 %= BASE
+        i += 16
       end
+      while len.nonzero?
+        len -= 1
+        adler += buf[i].ord
+        i += 1
+        sum2 += adler
+      end
+      adler %= BASE
+      sum2 %= BASE
+    end
 
-      return adler | (sum2 << 16)
-   end
+    return adler | (sum2 << 16)
+  end
 
-   @@crc_table = [
-      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
-      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
-      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
-      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
-      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
-      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
-      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
-      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
-      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
-      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
-      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
-      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
-      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
-      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
-      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
-      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
-      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
-      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
-      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
-      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
-      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
-      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
-      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
-      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
-      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
-      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
-      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
-      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
-      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
-      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
-      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
-      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
-      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
-      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
-      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
-      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
-      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
-      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
-      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
-      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
-      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
-      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
-      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
-      0x2d02ef8d]
-
-   # Tables of CRC-32s of all single-byte values, made by make_crc_table()
-   def get_crc_table()
-      @@crc_table
-   end
+  @@crc_table = [
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+    0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+    0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+    0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+    0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+    0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+    0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+    0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+    0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+    0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+    0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+    0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+    0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+    0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+    0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+    0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+    0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+    0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+    0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+    0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+    0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+    0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+    0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+    0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+    0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+    0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+    0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+    0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+    0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+    0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+    0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+    0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+    0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+    0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+    0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+    0x2d02ef8d
+  ]
+
+  # Tables of CRC-32s of all single-byte values, made by make_crc_table().
+  #
+  def get_crc_table
+    @@crc_table
+  end
 
-   # compute the CRC-32 of a data stream
-   def crc32(crc, buf, len=0)
-      return 0 if buf.nil?
-      len = buf.length if len.zero?
-      crc = crc ^ 0xffffffff
-      i = 0
+  # Compute the CRC-32 of a data stream.
+  #
+  def crc32(crc, buf, len=0)
+    return 0 if buf.nil?
+    len = buf.length if len.zero?
+    crc = crc ^ 0xffffffff
+    i = 0
 
-      while len >= 8
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-         i+=1
-         len -= 8
-      end
+    while len >= 8
+      8.times{
+        crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
+        i += 1
+      }
+      len -= 8
+    end
 
-      if len.nonzero?
-         loop do
-            crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
-            i+=1
-            len -= 1
-            break if len.zero?
-         end
+    if len.nonzero?
+      loop do
+        crc = @@crc_table[(crc ^ buf[i].ord) & 0xff] ^ (crc >> 8)
+        i += 1
+        len -= 1
+        break if len.zero?
       end
-      crc ^ 0xffffffff
-   end
+    end
 
-   OS_CODE = 0
-
-   SEEK_SET = 0
-   SEEK_CUR = 1
-   SEEK_END = 2
-   Z_EOF = -1
-   Z_BUFSIZE = 16384
-
-   @@gz_magic = "\x1F\x8B"
-
-   ASCII_FLAG  = 0x01
-   HEAD_CRC    = 0x02
-   EXTRA_FIELD = 0x04
-   ORIG_NAME   = 0x08
-   COMMENT_    = 0x10
-   RESERVED    = 0xE0
-
-   Gz_stream = Struct.new(
-      :stream,
-      :z_err,
-      :z_eof,
-      :file,
-      :inbuf,
-      :outbuf,
-      :crc,
-      :msg,
-      :path,
-      :transparent,
-      :mode,
-      :start,
-      :in,
-      :out,
-      :back,
-      :last
-   )
-
-   # Opens a gzip (.gz) file for reading or writing. The mode parameter
-   # is as in fopen ("rb" or "wb"). The file is given either by file descriptor
-   # or path name (if fd == -1).
-   #
-   # gz_open returns NULL if the file could not be opened or if there was
-   # insufficient memory to allocate the (de)compression state; errno
-   # can be checked to distinguish the two cases (if errno is zero, the
-   # zlib error is Z_MEM_ERROR).
-   #
-   def gz_open(path, mode, fd)
-      return nil if path.nil? || mode.nil?
+    crc ^ 0xffffffff
+  end
 
-      s = Gz_stream.new
-      s.stream = Z_stream.new
+  OS_CODE = 0
+
+  SEEK_SET = 0
+  SEEK_CUR = 1
+  SEEK_END = 2
+  Z_EOF = -1
+  Z_BUFSIZE = 16384
+
+  @@gz_magic = "\x1F\x8B"
+
+  ASCII_FLAG  = 0x01
+  HEAD_CRC    = 0x02
+  EXTRA_FIELD = 0x04
+  ORIG_NAME   = 0x08
+  COMMENT_    = 0x10
+  RESERVED    = 0xE0
+
+  Gz_stream = Struct.new(
+    :stream,
+    :z_err,
+    :z_eof,
+    :file,
+    :inbuf,
+    :outbuf,
+    :crc,
+    :msg,
+    :path,
+    :transparent,
+    :mode,
+    :start,
+    :in,
+    :out,
+    :back,
+    :last
+  )
+
+  # Opens a gzip (.gz) file for reading or writing. The mode parameter
+  # is as in fopen ("rb" or "wb"). The file is given either by file descriptor
+  # or path name (if fd == -1).
+  #
+  # gz_open returns NULL if the file could not be opened or if there was
+  # insufficient memory to allocate the (de)compression state; errno
+  # can be checked to distinguish the two cases (if errno is zero, the
+  # zlib error is Z_MEM_ERROR).
+  #
+  def gz_open(path, mode, fd)
+    return nil if path.nil? || mode.nil?
 
-      level = Z_DEFAULT_COMPRESSION
-      strategy = Z_DEFAULT_STRATEGY
+    s = Gz_stream.new
+    s.stream = Z_stream.new
 
-      s.stream.next_in = nil
-      s.stream.next_out = nil
-      s.stream.avail_in = 0
-      s.stream.avail_out = 0
-      s.stream.msg = ''
+    level = Z_DEFAULT_COMPRESSION
+    strategy = Z_DEFAULT_STRATEGY
 
-      s.file = nil
-      s.z_err = Z_OK
-      s.z_eof = false
-      s.inbuf = nil
-      s.outbuf = nil
-      s.in = 0
-      s.out = 0
-      s.back = Z_EOF
-      s.crc = crc32(0, nil)
-      s.msg = ''
-      s.transparent = false
-      s.path = path.dup
-      s.mode = nil
-
-      fmode = ''
-
-      mode.each_byte do |c|
-         s.mode = 'r' if c == ?r.ord
-         s.mode = 'w' if c == ?w.ord || c == ?a.ord
-
-         if c >= ?0.ord && c <= ?9.ord
-            level = c - ?0.ord
-         elsif c == ?f.ord
-            strategy = Z_FILTERED
-         elsif c == ?h.ord
-            strategy = Z_HUFFMAN_ONLY
-         elsif c == ?R.ord
-            strategy = Z_RLE
-         else
-            fmode += c.chr
-         end
-      end
+    s.stream.next_in = nil
+    s.stream.next_out = nil
+    s.stream.avail_in = 0
+    s.stream.avail_out = 0
+    s.stream.msg = ''
 
-      if s.mode.nil?
-         destroy(s)
-         return nil
+    s.file = nil
+    s.z_err = Z_OK
+    s.z_eof = false
+    s.inbuf = nil
+    s.outbuf = nil
+    s.in = 0
+    s.out = 0
+    s.back = Z_EOF
+    s.crc = crc32(0, nil)
+    s.msg = ''
+    s.transparent = false
+    s.path = path.dup
+    s.mode = nil
+
+    fmode = ''
+
+    mode.each_byte do |c|
+      s.mode = 'r' if c == ?r.ord
+      s.mode = 'w' if c == ?w.ord || c == ?a.ord
+
+      if c >= ?0.ord && c <= ?9.ord
+        level = c - ?0.ord
+      elsif c == ?f.ord
+        strategy = Z_FILTERED
+      elsif c == ?h.ord
+        strategy = Z_HUFFMAN_ONLY
+      elsif c == ?R.ord
+        strategy = Z_RLE
+      else
+        fmode += c.chr
       end
+    end
 
-      if s.mode == 'w'
-         err = deflateInit2(
-            s.stream,
-            level,
-            Z_DEFLATED,
-            -MAX_WBITS,
-            DEF_MEM_LEVEL,
-            strategy
-         )
-
-         s.outbuf = 0.chr * Z_BUFSIZE
-         s.stream.next_out = Bytef.new(s.outbuf)
-
-         if err != Z_OK || s.outbuf.nil?
-            destroy(s)
-            return nil
-         end
-      else
-         s.inbuf = 0.chr * Z_BUFSIZE
-         s.stream.next_in = Bytef.new(s.inbuf)
+    if s.mode.nil?
+      destroy(s)
+      return nil
+    end
 
-         err = inflateInit2_(s.stream, -MAX_WBITS, ZLIB_VERSION, s.stream.size)
+    if s.mode == 'w'
+      err = deflateInit2(
+        s.stream,
+        level,
+        Z_DEFLATED,
+        -MAX_WBITS,
+        DEF_MEM_LEVEL,
+        strategy
+      )
 
-         if err != Z_OK || s.inbuf.nil?
-            destroy(s)
-            return nil
-         end
-      end
+      s.outbuf = 0.chr * Z_BUFSIZE
+      s.stream.next_out = Bytef.new(s.outbuf)
 
-      s.stream.avail_out = Z_BUFSIZE
+      if err != Z_OK || s.outbuf.nil?
+        destroy(s)
+        return nil
+      end
+    else
+      s.inbuf = 0.chr * Z_BUFSIZE
+      s.stream.next_in = Bytef.new(s.inbuf)
 
-      errno = 0
-      s.file = fd < 0 ? File.new(path, fmode) : IO.new(fd, fmode)
+      err = inflateInit2_(s.stream, -MAX_WBITS, ZLIB_VERSION, s.stream.size)
 
-      if s.mode == 'w'
-         gzheader = 0.chr * 10
-         gzheader[0] = @@gz_magic[0]
-         gzheader[1] = @@gz_magic[1]
-         gzheader[2] = Z_DEFLATED.chr
-         gzheader[3] = 0.chr
-         gzheader[4] = 0.chr
-         gzheader[5] = 0.chr
-         gzheader[6] = 0.chr
-         gzheader[7] = 0.chr
-         gzheader[8] = 0.chr
-         gzheader[9] = OS_CODE.chr
-         s.file.write(gzheader)
-         s.start = 10
-      else
-         check_header(s)
-         s.start = s.file.pos - s.stream.avail_in
+      if err != Z_OK || s.inbuf.nil?
+        destroy(s)
+        return nil
       end
+    end
 
-      return s
-   end
+    s.stream.avail_out = Z_BUFSIZE
+
+    s.file = fd < 0 ? File.new(path, fmode) : IO.new(fd, fmode)
+
+    if s.mode == 'w'
+      gzheader = 0.chr * 10
+      gzheader[0] = @@gz_magic[0]
+      gzheader[1] = @@gz_magic[1]
+      gzheader[2] = Z_DEFLATED.chr
+      gzheader[3] = 0.chr
+      gzheader[4] = 0.chr
+      gzheader[5] = 0.chr
+      gzheader[6] = 0.chr
+      gzheader[7] = 0.chr
+      gzheader[8] = 0.chr
+      gzheader[9] = OS_CODE.chr
+      s.file.write(gzheader)
+      s.start = 10
+    else
+      check_header(s)
+      s.start = s.file.pos - s.stream.avail_in
+    end
 
-   # Opens a gzip (.gz) file for reading or writing.
-   #
-   def gzopen(path,mode)
-      return gz_open(path, mode, -1)
-   end
+    return s
+  end
 
-   # Associate a gzFile with the file descriptor fd. fd is not dup'ed here
-   # to mimic the behavio(u)r of fdopen.
-   #
-   def gzdopen(fd,mode)
-      return nil if fd < 0
-      name = "<fd:#{fd}"
-      return gz_open(name, mode, fd)
-   end
+  # Opens a gzip (.gz) file for reading or writing.
+  #
+  def gzopen(path,mode)
+    return gz_open(path, mode, -1)
+  end
 
-   # Update the compression level and strategy
-   #
-   def gzsetparams(file,level,strategy)
-      s = file
+  # Associate a gzFile with the file descriptor fd. fd is not dup'ed here
+  # to mimic the behavio(u)r of fdopen.
+  #
+  def gzdopen(fd,mode)
+    return nil if fd < 0
+    name = "<fd:#{fd}"
+    return gz_open(name, mode, fd)
+  end
 
-      if s.nil? || s.mode != 'w'
-         return Z_STREAM_ERROR
-      end
+  # Update the compression level and strategy
+  #
+  def gzsetparams(file,level,strategy)
+    s = file
 
-      if s.stream.avail_out.zero?
-         s.stream.next_out = Bytef.new(s.outbuf)
-         written = s.file.write(s.outbuf)
+    if s.nil? || s.mode != 'w'
+      return Z_STREAM_ERROR
+    end
 
-         if written != Z_BUFSIZE
-            s.z_err = Z_ERRNO
-         end
+    if s.stream.avail_out.zero?
+      s.stream.next_out = Bytef.new(s.outbuf)
+      written = s.file.write(s.outbuf)
 
-         s.stream.avail_out = Z_BUFSIZE
+      if written != Z_BUFSIZE
+        s.z_err = Z_ERRNO
       end
 
-      return deflateParams(s.stream, level, strategy)
-   end
-
-   # Read a byte from a gz_stream; update next_in and avail_in. Return EOF
-   # for end of file.
-   # IN assertion: the stream s has been sucessfully opened for reading.
-   #
-   def get_byte(s)
-      return Z_EOF if s.z_eof
-
-      if s.stream.avail_in.zero?
-         begin
-            s.inbuf = s.file.read(Z_BUFSIZE)
-            s.stream.avail_in = s.inbuf.length if s.inbuf
-         rescue
-            s.inbuf = nil
-            s.z_err = Z_ERRNO
-         end
+      s.stream.avail_out = Z_BUFSIZE
+    end
 
-         if s.inbuf.nil?
-            s.z_eof = true
-            return Z_EOF
-         end
-         s.stream.next_in = Bytef.new(s.inbuf)
-      end
+    return deflateParams(s.stream, level, strategy)
+  end
 
-      s.stream.avail_in-=1
-      _get_byte = s.stream.next_in.get
-      s.stream.next_in+=1
+  # Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+  # for end of file.
+  # IN assertion: the stream s has been sucessfully opened for reading.
+  #
+  def get_byte(s)
+    return Z_EOF if s.z_eof
+
+    if s.stream.avail_in.zero?
+       begin
+          s.inbuf = s.file.read(Z_BUFSIZE)
+          s.stream.avail_in = s.inbuf.length if s.inbuf
+       rescue
+          s.inbuf = nil
+          s.z_err = Z_ERRNO
+       end
 
-      return _get_byte
-   end
+       if s.inbuf.nil?
+          s.z_eof = true
+          return Z_EOF
+       end
+       s.stream.next_in = Bytef.new(s.inbuf)
+    end
 
-   # Reads a long in LSB order from the given gz_stream. Sets z_err in case
-   # of error.
-   def getLong(s)
-      x = 0.chr * 4
-      x[0] = (get_byte(s)).chr
-      x[1] = (get_byte(s)).chr
-      x[2] = (get_byte(s)).chr
-      c = get_byte(s)
-      x[3] = (c).chr
+    s.stream.avail_in-=1
+    _get_byte = s.stream.next_in.get
+    s.stream.next_in+=1
 
-      s.z_err = Z_DATA_ERROR if (c == Z_EOF)
+    return _get_byte
+  end
 
-      return (x.unpack('L').first)
-   end
+  # Reads a long in LSB order from the given gz_stream. Sets z_err in case
+  # of error.
+  def getLong(s)
+    x = 0.chr * 4
+    x[0] = (get_byte(s)).chr
+    x[1] = (get_byte(s)).chr
+    x[2] = (get_byte(s)).chr
+    c = get_byte(s)
+    x[3] = (c).chr
 
-   # Check the gzip header of a gz_stream opened for reading. Set the stream
-   # mode to transparent if the gzip magic header is not present; set s->err
-   # to Z_DATA_ERROR if the magic header is present but the rest of the header
-   # is incorrect.
-   #
-   # IN assertion: the stream s has already been created sucessfully;
-   #    s->stream.avail_in is zero for the first time, but may be non-zero
-   #    for concatenated .gz files.
-   #
-   def check_header(s)
-      len = s.stream.avail_in
+    s.z_err = Z_DATA_ERROR if (c == Z_EOF)
 
-      if len < 2 
-         if len.nonzero?
-            s.inbuf[0] = s.stream.next_in[0]
-         end
+    return (x.unpack('L').first)
+  end
 
-         begin
-            buf = s.file.read(Z_BUFSIZE >> len)
-            if buf
-               s.inbuf[len,buf.length] = buf
-               len = buf.length
-            else
-               len = 0
-            end
-         rescue
-            len = 0
-            s.z_err = Z_ERRNO
-         end
+  # Check the gzip header of a gz_stream opened for reading. Set the stream
+  # mode to transparent if the gzip magic header is not present; set s->err
+  # to Z_DATA_ERROR if the magic header is present but the rest of the header
+  # is incorrect.
+  #
+  # IN assertion: the stream s has already been created sucessfully;
+  #    s->stream.avail_in is zero for the first time, but may be non-zero
+  #    for concatenated .gz files.
+  #
+  def check_header(s)
+    len = s.stream.avail_in
 
-         s.stream.avail_in += len
-         s.stream.next_in = Bytef.new(s.inbuf)
+    if len < 2
+      if len.nonzero?
+        s.inbuf[0] = s.stream.next_in[0]
+      end
 
-         if s.stream.avail_in < 2
-            s.transparent = !s.stream.avail_in.zero?
-            return
-         end
+      begin
+        buf = s.file.read(Z_BUFSIZE >> len)
+        if buf
+          s.inbuf[len,buf.length] = buf
+          len = buf.length
+        else
+          len = 0
+        end
+      rescue
+        len = 0
+        s.z_err = Z_ERRNO
       end
 
-      if s.stream.next_in[0] != @@gz_magic[0].ord ||
-         s.stream.next_in[1] != @@gz_magic[1].ord
-      then
-         s.transparent = true
-         return
+      s.stream.avail_in += len
+      s.stream.next_in = Bytef.new(s.inbuf)
+
+      if s.stream.avail_in < 2
+        s.transparent = !s.stream.avail_in.zero?
+        return
       end
+    end
 
-      s.stream.avail_in -= 2
-      s.stream.next_in += 2
+    if s.stream.next_in[0] != @@gz_magic[0].ord ||
+      s.stream.next_in[1] != @@gz_magic[1].ord
+    then
+      s.transparent = true
+      return
+    end
 
-      method = get_byte(s)
-      flags = get_byte(s)
+    s.stream.avail_in -= 2
+    s.stream.next_in += 2
 
-      if (method != Z_DEFLATED) || (flags & RESERVED).nonzero?
-         s.z_err = Z_DATA_ERROR
-         return
-      end
+    method = get_byte(s)
+    flags = get_byte(s)
 
-      for len in 0 .. 5
-         get_byte(s)
-      end
+    if (method != Z_DEFLATED) || (flags & RESERVED).nonzero?
+      s.z_err = Z_DATA_ERROR
+      return
+    end
 
-      if (flags & EXTRA_FIELD).nonzero?
-         len = (get_byte(s))
-         len += ((get_byte(s)) << 8)
-         while len.nonzero? || (get_byte(s) != Z_EOF)
-             len -= 1
-         end
-      end
+    for len in 0 .. 5
+      get_byte(s)
+    end
 
-      if (flags & ORIG_NAME).nonzero?
-         loop do
-            c = get_byte(s)
-            break if c.zero? || (c == Z_EOF)
-         end
+    if (flags & EXTRA_FIELD).nonzero?
+      len = (get_byte(s))
+      len += ((get_byte(s)) << 8)
+      while len.nonzero? || (get_byte(s) != Z_EOF)
+        len -= 1
       end
+    end
 
-      if (flags & COMMENT_).nonzero?
-         loop do
-            c = get_byte(s)
-            break if c.zero? || (c == Z_EOF)
-         end
+    if (flags & ORIG_NAME).nonzero?
+      loop do
+        c = get_byte(s)
+        break if c.zero? || (c == Z_EOF)
       end
+    end
 
-      if (flags & HEAD_CRC).nonzero?
-         get_byte(s)
-         get_byte(s)
+    if (flags & COMMENT_).nonzero?
+      loop do
+        c = get_byte(s)
+        break if c.zero? || (c == Z_EOF)
       end
+    end
 
-      s.z_err = s.z_eof ? Z_DATA_ERROR : Z_OK
-   end
+    if (flags & HEAD_CRC).nonzero?
+      get_byte(s)
+      get_byte(s)
+    end
 
-   # Cleanup then free the given gz_stream. Return a zlib error code.
-   def destroy(s)
-      err = Z_OK
-      return Z_STREAM_ERROR if s.nil?
+    s.z_err = s.z_eof ? Z_DATA_ERROR : Z_OK
+  end
 
-      if s.stream.state
-         if s.mode == 'w'
-            err = deflateEnd(s.stream)
-         elsif s.mode == 'r'
-            err = inflateEnd(s.stream)
-         end
-      end
+  # Cleanup then free the given gz_stream. Return a zlib error code.
+  def destroy(s)
+    err = Z_OK
+    return Z_STREAM_ERROR if s.nil?
 
-      begin
-         s.file.close if s.file
-         s.file = nil
-      rescue
-         err = Z_ERRNO
+    if s.stream.state
+      if s.mode == 'w'
+        err = deflateEnd(s.stream)
+      elsif s.mode == 'r'
+        err = inflateEnd(s.stream)
       end
+    end
 
-      if s.z_err < 0
-         err = s.z_err
-      end
+    begin
+      s.file.close if s.file
+      s.file = nil
+    rescue
+      err = Z_ERRNO
+    end
 
-      return err
-   end
+    if s.z_err < 0
+      err = s.z_err
+    end
 
-   # Reads the given number of uncompressed bytes from the compressed file.
-   # gzread returns the number of bytes actually read (0 for end of file).
-   def gzread(file,buf,len)
-      s = file
-      start = Bytef.new(buf)
+    return err
+  end
 
-      if s.nil? || s.mode != 'r'
-         return Z_STREAM_ERROR
-      end
+  # Reads the given number of uncompressed bytes from the compressed file.
+  # gzread returns the number of bytes actually read (0 for end of file).
+  def gzread(file,buf,len)
+    s = file
+    start = Bytef.new(buf)
 
-      return -1 if (s.z_err == Z_DATA_ERROR) || (s.z_err == Z_ERRNO)
-      return 0 if (s.z_err == Z_STREAM_END)
-
-      next_out = Bytef.new(buf)
-      s.stream.next_out = Bytef.new(buf)
-      s.stream.avail_out = len
-
-      if s.stream.avail_out.nonzero? && s.back != Z_EOF
-         next_out.set(s.back)
-         next_out += 1
-         s.stream.next_out += 1
-         s.stream.avail_out -= 1
-         s.back = Z_EOF
-         s.out += 1
-         start += 1
-
-         if s.last
-            s.z_err = Z_STREAM_END
-            return 1
-         end
-      end
+    if s.nil? || s.mode != 'r'
+      return Z_STREAM_ERROR
+    end
 
-      while s.stream.avail_out.nonzero?
-         if s.transparent
-            n = s.stream.avail_in
+    return -1 if (s.z_err == Z_DATA_ERROR) || (s.z_err == Z_ERRNO)
+    return 0 if (s.z_err == Z_STREAM_END)
 
-            if n > s.stream.avail_out
-               n = s.stream.avail_out
-            end
+    next_out = Bytef.new(buf)
+    s.stream.next_out = Bytef.new(buf)
+    s.stream.avail_out = len
 
-            if n > 0
-               s.stream.next_out.buffer[s.stream.next_out.offset,n] = s.stream.next_in.current[0,n]
-               next_out += n
-               s.stream.next_out.offset = next_out.offset
-               s.stream.next_in += n
-               s.stream.avail_out -= n
-               s.stream.avail_in -= n
-            end
+    if s.stream.avail_out.nonzero? && s.back != Z_EOF
+      next_out.set(s.back)
+      next_out += 1
+      s.stream.next_out += 1
+      s.stream.avail_out -= 1
+      s.back = Z_EOF
+      s.out += 1
+      start += 1
 
-            if s.stream.avail_out > 0
-               buff = s.file.read(s.stream.avail_out)
-               if buff
-                  next_out.buffer[next_out.offset,buff.length] = buff
-                  s.stream.avail_out -= buff.length
-               end
-            end
+      if s.last
+        s.z_err = Z_STREAM_END
+        return 1
+      end
+    end
 
-            len -= s.stream.avail_out
-            s.in += len
-            s.out += len
-            if len.zero?
-               s.z_eof = true
-            end
-            return len
-         end
+    while s.stream.avail_out.nonzero?
+      if s.transparent
+        n = s.stream.avail_in
 
-         if s.stream.avail_in.zero? && !s.z_eof
-            begin
-               buf = s.file.read(Z_BUFSIZE)
-               if buf
-                  s.inbuf[0,buf.length] = buf
-                  s.stream.avail_in = buf.length
-               else
-                  s.stream.avail_in = 0
-               end
-            rescue
-               s.z_err = Z_ERRNO
-            end
+        if n > s.stream.avail_out
+          n = s.stream.avail_out
+        end
 
-            if s.stream.avail_in.zero?
-               s.z_eof = true
-               break if(s.z_err == Z_ERRNO)
-            end
-            s.stream.next_in = Bytef.new(s.inbuf)
-         end
+        if n > 0
+          s.stream.next_out.buffer[s.stream.next_out.offset,n] = s.stream.next_in.current[0,n]
+          next_out += n
+          s.stream.next_out.offset = next_out.offset
+          s.stream.next_in += n
+          s.stream.avail_out -= n
+          s.stream.avail_in -= n
+        end
 
-         s.in += s.stream.avail_in
-         s.out += s.stream.avail_out
-         s.z_err = inflate(s.stream, Z_NO_FLUSH)
-         s.in -= s.stream.avail_in
-         s.out -= s.stream.avail_out
-
-         if s.z_err == Z_STREAM_END
-            s.crc = crc32(s.crc, start.current,s.stream.next_out.offset - start.offset)
-            start = s.stream.next_out.dup
-            if getLong(s) != s.crc
-               s.z_err = Z_DATA_ERROR
-            else
-               getLong(s)
-               check_header(s)
-               if s.z_err == Z_OK
-                  inflateReset(s.stream)
-                  s.crc = crc32(0, nil)
-               end
-            end
-         end
+        if s.stream.avail_out > 0
+          buff = s.file.read(s.stream.avail_out)
+          if buff
+            next_out.buffer[next_out.offset,buff.length] = buff
+            s.stream.avail_out -= buff.length
+          end
+        end
+
+        len -= s.stream.avail_out
+        s.in += len
+        s.out += len
+
+        if len.zero?
+          s.z_eof = true
+        end
 
-         break if s.z_err != Z_OK || s.z_eof
+        return len
       end
 
-      s.crc = crc32(s.crc, start.current,s.stream.next_out.offset - start.offset)
+      if s.stream.avail_in.zero? && !s.z_eof
+        begin
+          buf = s.file.read(Z_BUFSIZE)
+          if buf
+            s.inbuf[0,buf.length] = buf
+            s.stream.avail_in = buf.length
+          else
+            s.stream.avail_in = 0
+          end
+        rescue
+          s.z_err = Z_ERRNO
+        end
 
-      if len == s.stream.avail_out && (s.z_err == Z_DATA_ERROR || s.z_err = Z_ERRNO)
-         return -1
+        if s.stream.avail_in.zero?
+          s.z_eof = true
+          break if(s.z_err == Z_ERRNO)
+        end
+        s.stream.next_in = Bytef.new(s.inbuf)
       end
 
-      return len - s.stream.avail_out
-   end
+      s.in += s.stream.avail_in
+      s.out += s.stream.avail_out
+      s.z_err = inflate(s.stream, Z_NO_FLUSH)
+      s.in -= s.stream.avail_in
+      s.out -= s.stream.avail_out
 
-   # Reads one byte from the compressed file. gzgetc returns this byte
-   # or -1 in case of end of file or error.
-   #
-   def gzgetc(file)
-      c = 0.chr
-      if (gzread(file,c,1) == 1)
-         return c
-      else
-         return -1
+      if s.z_err == Z_STREAM_END
+        s.crc = crc32(s.crc, start.current,s.stream.next_out.offset - start.offset)
+        start = s.stream.next_out.dup
+        if getLong(s) != s.crc
+          s.z_err = Z_DATA_ERROR
+        else
+          getLong(s)
+          check_header(s)
+          if s.z_err == Z_OK
+            inflateReset(s.stream)
+            s.crc = crc32(0, nil)
+          end
+        end
       end
-   end
 
-   # Push one byte back onto the stream.
-   #
-   def gzungetc(c, file)
-      s = file
-      return Z_EOF if s.nil? || s.mode != 'r' || c == Z_EOF || s.back != Z_EOF
-      s.back = c
-      s.out -= 1
-      s.last = (s.z_err == Z_STREAM_END)
-      s.z_err = Z_OK if s.last
-      s.z_eof = false
+      break if s.z_err != Z_OK || s.z_eof
+    end
+
+    s.crc = crc32(s.crc, start.current,s.stream.next_out.offset - start.offset)
+
+    if len == s.stream.avail_out && (s.z_err == Z_DATA_ERROR || s.z_err = Z_ERRNO)
+      return -1
+    end
+
+    return len - s.stream.avail_out
+  end
+
+  # Reads one byte from the compressed file. gzgetc returns this byte
+  # or -1 in case of end of file or error.
+  #
+  def gzgetc(file)
+    c = 0.chr
+    if (gzread(file,c,1) == 1)
       return c
-   end
+    else
+      return -1
+    end
+  end
 
-   # Reads bytes from the compressed file until len-1 characters are
-   # read, or a newline character is read and transferred to buf, or an
-   # end-of-file condition is encountered.  The string is then terminated
-   # with a null character.
-   #
-   # Returns buf, or Z_NULL in case of error.
-   #
-   def gzgets(file,buf,len)
-      return nil if buf.nil? || (len <= 0)
+  # Push one byte back onto the stream.
+  #
+  def gzungetc(c, file)
+    s = file
+    return Z_EOF if s.nil? || s.mode != 'r' || c == Z_EOF || s.back != Z_EOF
+    s.back = c
+    s.out -= 1
+    s.last = (s.z_err == Z_STREAM_END)
+    s.z_err = Z_OK if s.last
+    s.z_eof = false
+    return c
+  end
 
-      i = 0
-      gzchar = 0.chr
+  # Reads bytes from the compressed file until len-1 characters are
+  # read, or a newline character is read and transferred to buf, or an
+  # end-of-file condition is encountered.  The string is then terminated
+  # with a null character.
+  #
+  # Returns buf, or Z_NULL in case of error.
+  #
+  def gzgets(file,buf,len)
+    return nil if buf.nil? || (len <= 0)
 
-      loop do
-         len-=1
-         bytes = gzread(file, gzchar, 1)
-         buf[i] = gzchar[0]
-         i += 1
-         break if len.zero? || (bytes != 1) || (gzchar == (13).chr)
-      end
+    i = 0
+    gzchar = 0.chr
 
-      buf[i..-1] = ''
-      buf.chomp!(0.chr)
+    loop do
+      len-=1
+      bytes = gzread(file, gzchar, 1)
+      buf[i] = gzchar[0]
+      i += 1
+      break if len.zero? || (bytes != 1) || (gzchar == (13).chr)
+    end
 
-      if i.zero? && (len > 0)
-         return nil
-      else
-         return buf
-      end
+    buf[i..-1] = ''
+    buf.chomp!(0.chr)
+
+    if i.zero? && (len > 0)
+      return nil
+    else
+      return buf
+    end
   end
 
   #   Writes the given number of uncompressed bytes into the compressed file.
@@ -1204,11 +1197,11 @@ module Rbzlib
 
   # Outputs a long in LSB order to the given file
   def putLong(s,x)
-    for n in 0 .. 3
+    4.times{
       c = x & 0xFF
       s.putc(c)
       x = x >> 8
-    end
+    }
   end
 
    # Flushes all pending output if necessary, closes the compressed file
@@ -2455,7 +2448,7 @@ module Rbzlib
       end
     end
     if (s.match_available)
-      bflush = _tr_tally(s, 0, s.window[s.strstart-1].ord)
+      _tr_tally(s, 0, s.window[s.strstart-1].ord)
       s.match_available = false
     end
     FLUSH_BLOCK_ONLY(s, flush == Z_FINISH)
@@ -2871,15 +2864,15 @@ module Rbzlib
     end
 
     h = HEAP_SIZE
-    max_length.downto(1) do |bits|
-      n = s.bl_count[bits]
+    max_length.downto(1) do |nbits|
+      n = s.bl_count[nbits]
       while n.nonzero?
         h -= 1
         m = s.heap[h]
         next if (m > max_code)
-        if (tree[m].dl != bits)
-          s.opt_len += (bits - tree[m].dl) * tree[m].fc
-          tree[m].dl = bits
+        if (tree[m].dl != nbits)
+          s.opt_len += (nbits - tree[m].dl) * tree[m].fc
+          tree[m].dl = nbits
         end
         n-=1
       end
@@ -2931,8 +2924,8 @@ module Rbzlib
     end
     desc.max_code = max_code
 
-    (s.heap_len / 2).downto(1) do |n|
-      pqdownheap(s, tree, n)
+    (s.heap_len / 2).downto(1) do |nheap|
+      pqdownheap(s, tree, nheap)
     end
 
     node = elems
@@ -3619,10 +3612,10 @@ module Rbzlib
     dmask = (1 << state.distbits) - 1
     status = nil
     this = nil
-    
+
     op = -1
     len = -1
-    
+
     loop do
       if status.nil?
         if (bits < 15)
@@ -3808,20 +3801,20 @@ module Rbzlib
                 state.mode = BAD
                 break
             end
-        elsif (op & 64).zero?
-            this = lcode[this.val + (hold & ((1 << op) - 1))]
-            status = :dolen
-            redo
-        elsif (op & 32).nonzero?
-            state.mode = TYPE
-            break
-        else
-            strm.msg = "invalid literal/length code"
-            state.mode = BAD
-            break
-        end
-        status = nil
-        break unless (_in.offset < last.offset && out.offset < _end.offset)
+      elsif (op & 64).zero?
+          this = lcode[this.val + (hold & ((1 << op) - 1))]
+          status = :dolen
+          redo
+      elsif (op & 32).nonzero?
+          state.mode = TYPE
+          break
+      else
+          strm.msg = "invalid literal/length code"
+          state.mode = BAD
+          break
+      end
+      status = nil
+      break unless (_in.offset < last.offset && out.offset < _end.offset)
     end
     len = bits >> 3
     _in -= len
@@ -4159,12 +4152,12 @@ module Rbzlib
   # Get a byte of input into the bit accumulator, or return from inflate()
   # if there is no input available.
   def PULLBYTE()
-        throw :inf_leave if @@have.zero?
-        @@have -= 1
-        c = (@@next.get)
-        @@hold += (@@next.get) << @@bits
-        @@next += 1
-        @@bits += 8
+    throw :inf_leave if @@have.zero?
+    @@have -= 1
+    @@next.get
+    @@hold += (@@next.get) << @@bits
+    @@next += 1
+    @@bits += 8
   end
 
   # Assure that there are at least n bits in the bit accumulator.  If there is
@@ -4959,7 +4952,7 @@ module Rbzlib
             state.bits -= 8
         end
         state.have = 0
-        _next,state.have = syncsearch((state.have), buf, len)
+        _,state.have = syncsearch((state.have), buf, len)
     end
 
     len,state.have = syncsearch((state.have), strm.next_in, strm.avail_in)