amp 0.5.0

data/Rakefile

@@ -0,0 +1,102 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'rake'
+require 'rake/tasklib'
+require 'rake/testtask'
+require 'yard'
+require 'hoe'
+
+Rake::TaskManager.class_eval do
+  def remove_task(*task_names)
+    task_names.each do |task_name|
+      @tasks.delete(task_name.to_s)
+    end
+  end
+end
+
+def remove_task(*task_names)
+  task_names.each do |task_name|
+    Rake.application.remove_task(task_name)
+  end
+end
+ 
+
+Hoe.spec "amp" do
+  developer "Michael Edgar", "adgar@carboni.ca"
+  developer "Ari Brown", "seydar@carboni.ca"
+  self.url = "http://amp.carboni.ca/"
+  self.spec_extras = {:extensions => ["ext/amp/mercurial_patch/extconf.rb",
+                                      "ext/amp/priority_queue/extconf.rb",
+                                      "ext/amp/support/extconf.rb",
+                                      "ext/amp/bz2/extconf.rb"]}
+  self.need_rdoc = false
+  self.flog_threshold = 50000
+  self.summary = "Version Control in Ruby. Mercurial Compatible. Big Ideas."
+end
+ 
+# Hoe.spec "amp-pure" do
+#   developer "Michael Edgar", "adgar@carboni.ca"
+#   developer "Ari Brown", "seydar@carboni.ca"
+#   self.url = "http://amp.carboni.ca/"
+#   
+#   self.need_rdoc = false
+#   self.flog_threshold = 50000
+#   self.summary = "Version Control in Ruby. Mercurial Compatible. Big Ideas. (Pure-Ruby version)"
+# end
+
+
+
+remove_task 'test_deps', 'publish_docs', 'post_blog', 
+            'deps:fetch', 'deps:list', 'deps:email', 'flay', 'clean', 'test'
+
+load 'tasks/yard.rake'
+load 'tasks/stats.rake'
+
+desc "Build the C extensions"
+task :build do
+  curdir = File.expand_path(File.dirname(__FILE__))
+  ruby_exe = RUBY_VERSION < "1.9" ? "ruby" : "ruby1.9"
+  Dir['ext/amp/*', 'ext/bz2'].each do |target|
+    sh "cd #{File.join(curdir, target)}; #{ruby_exe} #{File.join(curdir, target, "extconf.rb")}" # this is necessary because ruby will build the Makefile in '.'
+    sh "cd #{File.join(curdir, target)}; make"
+  end
+end
+
+desc "Clean out the compiled code"
+task :clean do
+  sh "rm -rf ext/**/*.o"
+  sh "rm -rf ext/**/Makefile"
+  sh "rm -rf ext/**/*.bundle"
+  sh "rm -rf ext/**/*.so"
+  sh "rm -rf ext/amp/**/*.o"
+  sh "rm -rf ext/amp/**/Makefile"
+  sh "rm -rf ext/amp/**/*.bundle"
+  sh "rm -rf ext/amp/**/*.so"
+end
+
+desc "Clean and buld the C-extensions"
+task :rebuild => [:clean, :build]
+
+desc "Prepares for testing"
+task :prepare do
+  `tar -C test/store_tests/ -xzf test/store_tests/store.tar.gz`
+  `tar -C test/localrepo_tests/ -xzf test/localrepo_tests/testrepo.tar.gz`
+end
+
+# liberally modified from Hoe's
+desc 'Test the amp AWESOMENESS.'
+task :test do
+  framework = "test/unit"
+  test_globs = ['test/**/test_*.rb']
+  ruby_flags = ENV['RUBY_FLAGS'] || "-w -I#{%w(lib ext bin test).join(File::PATH_SEPARATOR)}" +
+    (ENV['RUBY_DEBUG'] ? " #{ENV['RUBY_DEBUG']}" : '')
+  tests = [ framework] +
+    test_globs.map { |g| Dir.glob(g) }.flatten
+  tests.map! {|f| %(require "#{f}")}
+  cmd = "#{ruby_flags} -e '$amp_testing = true; #{tests.join("; ")}' "
+  
+  ruby cmd
+end
+
+# vim: syntax=Ruby

data/SCHEDULE.markdown

@@ -0,0 +1,12 @@
+These are the release names for each version, in order. Every time a major
+release happens, use the next name on the list.
+
+- √ Nikki & Paolo
+- √ Leslie Arzt
+- √ Ethan Rom
+- √ Danielle Rousseau
+- √ Mr. Eko
+- √ Charles Hieronymus Pace
+- John Locke
+- Christian Shephard
+- The Smoke Monster

data/STYLE

@@ -0,0 +1,27 @@
+The Amp Commandments:
+    1. Thou shalt not useth the "for...in" syntax.
+    2. Thou shalt useth only but 80 columns, for those who useth the elden
+       editors, vim and emacs.
+    3. Thou shalt preface thine variables with _ only when thou needest,
+       lest ye face judgement for this most grave sin.
+    4. Thine variables should have descriptive names, for thine ruby must
+       read like the psalms.
+    5. Thine variables, longer than 6 letters and composed of two or more
+       words, shall separate those words with the lord's underscore, so thine
+       code shall flow like the Nile herself.
+    6. Thou shalt rake thine yard frequently, to be sure thine code is
+       well-documented for thine neighbors.
+    7. Thou shalt use alias_method over alias or I shall goeth Chris Brown
+       all over thou.
+    8. Thou shalt use parentheses in thine defintions of methods, for the
+       consistency of the codes in this repository. Sir William Morgan will
+       have to change the style of himself, for his is strange yet beautiful
+       but still unwanted like a D of the ST kind.
+    9. Thine comments shall start, when above thine method definitions, with
+       2 (two) hashes, and the information, then, beginning on the line below
+       it. Thou shalt leave one blank comment line between thine comment info
+       and thine yard information.
+    10. Thou shalt make great and grand use of the yard extension. It is good.
+    11. Name thine motherfucking variables motherfucking descriptively.
+	12. For thine ranges, thou shalt place but 1 space on either side of the
+		ellipses.

data/TODO.markdown

@@ -0,0 +1,149 @@
+Amp::Patch::Patch
+=================
+
+Amp::Patch::Patch#hash\_lines
+-----------------------------
+  - 
+
+Amp::Patch::Patch#hash=
+-----------------------
+  - 
+
+Amp::Patch::Patch#find\_lines
+-----------------------------
+  - 
+
+Amp::Patch::Patch#hash
+----------------------
+  - 
+
+Amp::Patch::Patch#hunks=
+------------------------
+  - 
+
+Amp::Patch::Patch#hunks
+-----------------------
+  - 
+
+Amp::Patch::Patch#offset=
+-------------------------
+  - 
+
+Amp::Patch::Patch#lines=
+------------------------
+  - 
+
+Amp::Patch::Patch#offset
+------------------------
+  - 
+
+Amp::Patch::Patch#lines
+-----------------------
+  - 
+
+
+Amp::Support::Template
+======================
+
+Amp::Support::Template#render
+-----------------------------
+  - 
+
+
+Amp::Repositories::HTTPRepository
+=================================
+
+Amp::Repositories::HTTPRepository#changegroup
+---------------------------------------------
+  - 
+
+
+Amp::RevlogSupport::IndexInlineNG
+=================================
+
+Amp::RevlogSupport::IndexInlineNG#parse\_file
+---------------------------------------------
+  - 
+
+
+File
+====
+
+File.amp\_find\_executable
+--------------------------
+  - 
+
+File.amp\_set\_executable
+-------------------------
+  - 
+
+File.amp\_lookup\_reg
+---------------------
+  - 
+
+
+Amp::Revlog
+===========
+
+Amp::Revlog#check\_inline\_size
+-------------------------------
+  - 
+  - 
+
+
+Amp::ChangeLog
+==============
+
+Amp::ChangeLog#add
+------------------
+  - 
+
+Amp::ChangeLog#read
+-------------------
+  - 
+
+
+Amp::Repositories::DirState
+===========================
+
+Amp::Repositories::DirState#normalize
+-------------------------------------
+  - 
+
+Amp::Repositories::DirState#write
+---------------------------------
+  - 
+
+
+Amp::Repositories::LocalRepository
+==================================
+
+Amp::Repositories::LocalRepository#push\_add\_changegroup
+---------------------------------------------------------
+  - 
+
+Amp::Repositories::LocalRepository#push\_unbundle
+-------------------------------------------------
+  - 
+
+Amp::Repositories::Updatable#update
+-----------------------------------
+  - 
+
+Amp::Repositories::LocalRepository#changegroup\_info
+----------------------------------------------------
+  - 
+
+Amp::Repositories::TagManager#read\_tags
+----------------------------------------
+  - 
+
+Amp::Repositories::Updatable#apply\_updates
+-------------------------------------------
+  - 
+
+Amp::Repositories::LocalRepository#pre\_push
+--------------------------------------------
+  - 
+
+

data/ampfile.rb

@@ -0,0 +1,47 @@
+# need { 'lib/amp/extensions/ditz' }
+# need { 'lib/amp/extensions/lighthouse' }
+
+# Amp::LighthouseHook.add_hooks(:commit) do |hook|
+#   hook.token   = 'e4d6af1951c240e00c216bad3c52cf269cba4a7c'
+#   hook.account = 'carbonica'
+#   hook.project = 'amp'
+# end
+
+Amp::Command.new("silly") do |c|
+  c.workflow :hg
+  c.on_run do |options, args|
+    puts "You're silly!"
+    puts "You're REALLLY silly!"
+  end
+  c.desc "tell you how silly you are"
+end
+
+# command :push do |c|
+#   c.before { system "rake test" }
+# end
+
+template :silly, <<-EOF
+<%= change_node.inspect %> <%= revision %>
+EOF
+
+
+namespace :docs do
+  
+  command "gen" do |c|
+    c.desc "create the docs"
+    c.on_run {|o, a| `rake yard:doc`; puts 'docs made!' }
+  end
+  
+  command "upload" do |c|
+    c.desc "upload the docs"
+    c.on_run {|o, a| puts "docs uploaded!!!!" }
+  end
+  
+  namespace :search do
+    
+    command "methods" do |c|
+      c.desc "search method names"
+      c.on_run {|o, a| puts "#{a.inspect}"}
+    end
+  end
+end

data/bin/amp

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+def caller_file(level=0)
+  if caller[level]
+    File.expand_path(caller[level].split(":").first)
+  else
+    nil
+  end
+end
+
+private :caller_file
+
+$start   = Time.now
+$display = true
+$cl      = true # this lets us know we're a command line app
+$amp_executable = File.expand_path(__FILE__)
+
+ARGV.each { |arg| $USE_RUBY = true if arg == "--pure-ruby" || arg == '-u' }
+
+def follow_link(file)
+  file = File.expand_path(file)
+  while File.symlink?(file)
+    file = File.expand_path(File.readlink(file), File.dirname(file))
+  end
+  file
+end
+
+require File.join(File.dirname(follow_link(__FILE__)), "..", "lib", "amp")
+
+Amp::Dispatch.run

data/bin/amp1.9

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby1.9
+
+def caller_file(level=0)
+  if caller[level]
+    File.expand_path(caller[level].split(":").first)
+  else
+    nil
+  end
+end
+
+private :caller_file
+
+$start   = Time.now
+$display = true
+$cl      = true # this lets us know we're a command line app
+$amp_executable = File.expand_path(__FILE__)
+
+ARGV.each { |arg| $USE_RUBY = true if arg == "--pure-ruby" || arg == '-u' }
+
+def follow_link(file)
+  file = File.expand_path(file)
+  while File.symlink?(file)
+    file = File.expand_path(File.readlink(file), File.dirname(file))
+  end
+  file
+end
+
+require File.join(File.dirname(follow_link(__FILE__)), "..", "lib", "amp")
+
+Amp::Dispatch.run

data/ext/amp/bz2/README.txt

@@ -0,0 +1,39 @@
+= This is an interface to the library libbzip2
+
+* Installation
+ 
+   ruby extconf.rb
+   make
+   make install
+ 
+== You may need to specify :
+
+  --with-bz2-include=<include file directory for libbzip2>
+
+  --with-bz2-lib=<library directory for libbzip2>
+
+  --with-bz2-dir=<prefix for library and include of libbzip2>
+
+== Example :
+ 
+  ruby extconf.rb --with-bz2-dir=/home/ts/local
+
+* Documentation :
+
+    make rd2
+    make rdoc
+    make ri
+
+* Tests : if you have rubyunit, or testunit
+
+   make test
+
+* Copying
+ 
+ This extension module is copyrighted free software by Guy Decoux
+ 
+ You can redistribute it and/or modify it under the same term as
+ Ruby.
+ 
+ 
+Guy Decoux <ts@moulon.inra.fr>

data/ext/amp/bz2/bz2.c

@@ -0,0 +1,1582 @@
+#include <ruby.h>
+#include <rubyio.h>
+#include <bzlib.h>
+#include <version.h>
+
+static VALUE bz_cWriter, bz_cReader, bz_cInternal;
+static VALUE bz_eError, bz_eConfigError, bz_eEOZError;
+
+static VALUE bz_internal_ary;
+
+static ID id_new, id_write, id_open, id_flush, id_read;
+static ID id_closed, id_close, id_str;
+
+#define BZ2_RB_CLOSE    1
+#define BZ2_RB_INTERNAL 2
+
+struct bz_file {
+    bz_stream bzs;
+    VALUE in, io;
+    char *buf;
+    int buflen;
+    int blocks, work, small;
+    int flags, lineno, state;
+};
+
+struct bz_str {
+    VALUE str;
+    int pos;
+};
+
+struct bz_iv {
+    VALUE bz2, io;
+    void (*finalize)();
+};
+
+#define Get_BZ2(obj, bzf)			\
+    rb_io_taint_check(obj);			\
+    Data_Get_Struct(obj, struct bz_file, bzf);	\
+    if (!RTEST(bzf->io)) {			\
+	rb_raise(rb_eIOError, "closed IO");	\
+    }
+
+static VALUE
+bz_raise(error)
+    int error;
+{
+    VALUE exc;
+    char *msg;
+
+    exc = bz_eError;
+    switch (error) {
+    case BZ_SEQUENCE_ERROR:
+	msg = "uncorrect sequence"; 
+	break;
+    case BZ_PARAM_ERROR: 
+	msg = "parameter out of range";
+	break;
+    case BZ_MEM_ERROR: 
+	msg = "not enough memory is available"; 
+	break;
+    case BZ_DATA_ERROR:
+	msg = "data integrity error is detected";
+	break;
+    case BZ_DATA_ERROR_MAGIC:
+	msg = "compressed stream does not start with the correct magic bytes";
+	break;
+    case BZ_IO_ERROR: 
+	msg = "error reading or writing"; 
+	break;
+    case BZ_UNEXPECTED_EOF: 
+	exc = bz_eEOZError;
+	msg = "compressed file finishes before the logical end of stream is detected";
+	break;
+    case BZ_OUTBUFF_FULL:
+	msg = "output buffer full";
+	break;
+    case BZ_CONFIG_ERROR:
+	exc = bz_eConfigError;
+	msg = "library has been improperly compiled on your platform";
+	break;
+    default:
+	msg = "unknown error";
+	exc = bz_eError;
+    }
+    rb_raise(exc, msg);
+}
+    
+static void
+bz_str_mark(bzs)
+    struct bz_str *bzs;
+{
+    rb_gc_mark(bzs->str);
+}
+
+static void
+bz_file_mark(bzf)
+    struct bz_file *bzf;
+{
+    rb_gc_mark(bzf->io);
+    rb_gc_mark(bzf->in);
+}
+
+static struct bz_iv *
+bz_find_struct(obj, ptr, posp)
+    VALUE obj;
+    void *ptr;
+    int *posp;
+{
+    struct bz_iv *bziv;
+    int i;
+
+    for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
+	Data_Get_Struct(RARRAY_PTR(bz_internal_ary)[i], struct bz_iv, bziv);
+	if (ptr) {
+	    if (TYPE(bziv->io) == T_FILE && 
+		RFILE(bziv->io)->fptr == (OpenFile *)ptr) {
+		if (posp) *posp = i;
+		return bziv;
+	    }
+	    else if (TYPE(bziv->io) == T_DATA &&
+		     DATA_PTR(bziv->io) == ptr) {
+		if (posp) *posp = i;
+		return bziv;
+	    }
+	}
+	else if (bziv->io == obj) {
+	    if (posp) *posp = i;
+	    return bziv;
+	}
+    }
+    if (posp) *posp = -1;
+    return 0;
+}
+
+static VALUE
+bz_writer_internal_flush(bzf)
+    struct bz_file *bzf;
+{
+    int closed = 1;
+
+    if (rb_respond_to(bzf->io, id_closed)) {
+	closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
+    }
+    if (bzf->buf) {
+	if (!closed && bzf->state == BZ_OK) {
+	    bzf->bzs.next_in = NULL;
+	    bzf->bzs.avail_in = 0;
+	    do {
+		bzf->bzs.next_out = bzf->buf;
+		bzf->bzs.avail_out = bzf->buflen;
+		bzf->state = BZ2_bzCompress(&(bzf->bzs), BZ_FINISH);
+		if (bzf->state != BZ_FINISH_OK && 
+		    bzf->state != BZ_STREAM_END) {
+		    break;
+		}
+		if (bzf->bzs.avail_out < bzf->buflen) {
+		    rb_funcall(bzf->io, id_write, 1,
+			       rb_str_new(bzf->buf, 
+					  bzf->buflen - bzf->bzs.avail_out));
+		}
+	    } while (bzf->state != BZ_STREAM_END);
+	}
+	free(bzf->buf);
+	bzf->buf = 0;
+	BZ2_bzCompressEnd(&(bzf->bzs));
+	bzf->state = BZ_OK;
+	if (!closed && rb_respond_to(bzf->io, id_flush)) {
+	    rb_funcall2(bzf->io, id_flush, 0, 0);
+	}
+    }
+    return closed;
+}
+
+static VALUE
+bz_writer_internal_close(bzf)
+    struct bz_file *bzf;
+{
+    struct bz_iv *bziv;
+    int pos, closed;
+    VALUE res;
+
+    closed = bz_writer_internal_flush(bzf);
+    bziv = bz_find_struct(bzf->io, 0, &pos);
+    if (bziv) {
+	if (TYPE(bzf->io) == T_FILE) {
+	    RFILE(bzf->io)->fptr->finalize = bziv->finalize;
+	}
+	else if (TYPE(bziv->io) == T_DATA) {
+	    RDATA(bziv->io)->dfree = bziv->finalize;
+	}
+	RDATA(bziv->bz2)->dfree = ruby_xfree;
+	bziv->bz2 = 0;
+	rb_ary_delete_at(bz_internal_ary, pos);
+    }
+    if (bzf->flags & BZ2_RB_CLOSE) {
+	bzf->flags &= ~BZ2_RB_CLOSE;
+	if (!closed && rb_respond_to(bzf->io, id_close)) {
+	    rb_funcall2(bzf->io, id_close, 0, 0);
+	}
+	res = Qnil;
+    }
+    else {
+	res = bzf->io;
+    }
+    bzf->io = Qnil;
+    return res;
+}
+
+static VALUE
+bz_internal_finalize(ary, obj)
+    VALUE ary, obj;
+{
+    VALUE elem;
+    int closed, i;
+    struct bz_iv *bziv;
+    struct bz_file *bzf;
+
+    for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
+	elem = RARRAY_PTR(bz_internal_ary)[i];
+	Data_Get_Struct(elem, struct bz_iv, bziv);
+	if (bziv->bz2) {
+	    RDATA(bziv->bz2)->dfree = ruby_xfree;
+	    if (TYPE(bziv->io) == T_FILE) {
+		RFILE(bziv->io)->fptr->finalize = bziv->finalize;
+	    }
+	    else if (TYPE(bziv->io) == T_DATA) {
+		RDATA(bziv->io)->dfree = bziv->finalize;
+	    }
+	    Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
+	    closed = bz_writer_internal_flush(bzf);
+	    if (bzf->flags & BZ2_RB_CLOSE) {
+		bzf->flags &= ~BZ2_RB_CLOSE;
+		if (!closed && rb_respond_to(bzf->io, id_close)) {
+		    rb_funcall2(bzf->io, id_close, 0, 0);
+		}
+	    }
+	}
+    }
+    return Qnil;
+}
+
+static VALUE
+bz_writer_close(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE res;
+
+    Get_BZ2(obj, bzf);
+    res = bz_writer_internal_close(bzf);
+    if (!NIL_P(res) && (bzf->flags & BZ2_RB_INTERNAL)) {
+	RBASIC(res)->klass = rb_cString;
+    }
+    return res;
+}
+
+static VALUE
+bz_writer_close_bang(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    int closed;
+
+    Get_BZ2(obj, bzf);
+    closed = bzf->flags & (BZ2_RB_INTERNAL|BZ2_RB_CLOSE);
+    bz_writer_close(obj);
+    if (!closed && rb_respond_to(bzf->io, id_close)) {
+	if (rb_respond_to(bzf->io, id_closed)) {
+	    closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
+	}
+	if (!closed) {
+	    rb_funcall2(bzf->io, id_close, 0, 0);
+	}
+    }
+    return Qnil;
+}
+
+static void
+bz_writer_free(bzf)
+    struct bz_file *bzf;
+{
+    bz_writer_internal_close(bzf);
+    ruby_xfree(bzf);
+}
+
+static void
+bz_io_data_finalize(ptr)
+    void *ptr;
+{
+    struct bz_file *bzf;
+    struct bz_iv *bziv;
+    int pos;
+
+    bziv = bz_find_struct(0, ptr, &pos);
+    if (bziv) {
+	rb_ary_delete_at(bz_internal_ary, pos);
+	Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
+	rb_protect(bz_writer_internal_flush, (VALUE)bzf, 0);
+	RDATA(bziv->bz2)->dfree = ruby_xfree;
+	if (bziv->finalize) {
+	    (*bziv->finalize)(ptr);
+	}
+	else if (TYPE(bzf->io) == T_FILE) {
+	    OpenFile *file = (OpenFile *)ptr;
+	    if (file->f) {
+		fclose(file->f);
+		file->f = 0;
+	    }
+	    if (file->f2) {
+		fclose(file->f2);
+		file->f2 = 0;
+	    }
+	}
+    }
+}
+
+static void *
+bz_malloc(opaque, m, n)
+    void *opaque;
+    int m, n;
+{
+    return ruby_xmalloc(m * n);
+}
+
+static void
+bz_free(opaque, p)
+    void *opaque, *p;
+{
+    ruby_xfree(p);
+}
+
+#define DEFAULT_BLOCKS 9
+
+static VALUE
+bz_writer_s_alloc(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE res;
+    res = Data_Make_Struct(obj, struct bz_file, bz_file_mark, 
+			   bz_writer_free, bzf);
+    bzf->bzs.bzalloc = bz_malloc;
+    bzf->bzs.bzfree = bz_free;
+    bzf->blocks = DEFAULT_BLOCKS;
+    bzf->state = BZ_OK;
+    return res;
+}
+
+static VALUE
+bz_writer_flush(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    if (bzf->flags & BZ2_RB_INTERNAL) {
+	return bz_writer_close(obj);
+    }
+    bz_writer_internal_flush(bzf);
+    return Qnil;
+}
+
+static VALUE
+bz_writer_s_open(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE res;
+    struct bz_file *bzf;
+
+    if (argc < 1) {
+	rb_raise(rb_eArgError, "invalid number of arguments");
+    }
+    if (argc == 1) {
+	argv[0] = rb_funcall(rb_mKernel, id_open, 2, argv[0], 
+			     rb_str_new2("wb"));
+    }
+    else {
+	argv[1] = rb_funcall2(rb_mKernel, id_open, 2, argv);
+	argv += 1;
+	argc -= 1;
+    }
+    res = rb_funcall2(obj, id_new, argc, argv);
+    Data_Get_Struct(res, struct bz_file, bzf);
+    bzf->flags |= BZ2_RB_CLOSE;
+    if (rb_block_given_p()) {
+	return rb_ensure(rb_yield, res, bz_writer_close, res);
+    }
+    return res;
+}
+
+static VALUE
+bz_str_write(obj, str)
+    VALUE obj, str;
+{
+    if (TYPE(str) != T_STRING) {
+	rb_raise(rb_eArgError, "expected a String");
+    }
+    if (RSTRING_LEN(str)) {
+	rb_str_cat(obj, RSTRING_PTR(str), RSTRING_LEN(str));
+    }
+    return str;
+}
+
+static VALUE
+bz_str_closed(obj)
+    VALUE obj;
+{
+    return Qfalse;
+}
+
+static VALUE
+bz_writer_init(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    struct bz_file *bzf;
+    int blocks = DEFAULT_BLOCKS;
+    int work = 0;
+    VALUE a, b, c;
+
+    switch(rb_scan_args(argc, argv, "03", &a, &b, &c)) {
+    case 3:
+	work = NUM2INT(c);
+	/* ... */
+    case 2:
+	blocks = NUM2INT(b);
+    }
+    Data_Get_Struct(obj, struct bz_file, bzf);
+    if (NIL_P(a)) {
+	a = rb_str_new(0, 0);
+	rb_define_method(rb_singleton_class(a), "write", bz_str_write, 1);
+	rb_define_method(rb_singleton_class(a), "closed?", bz_str_closed, 0);
+	bzf->flags |= BZ2_RB_INTERNAL;
+    }
+    else {
+	VALUE iv;
+	struct bz_iv *bziv;
+	OpenFile *fptr;
+
+	rb_io_taint_check(a);
+	if (!rb_respond_to(a, id_write)) {
+	    rb_raise(rb_eArgError, "first argument must respond to #write");
+	}
+	if (TYPE(a) == T_FILE) {
+	    GetOpenFile(a, fptr);
+	    rb_io_check_writable(fptr);
+	}
+	else if (rb_respond_to(a, id_closed)) {
+	    iv = rb_funcall2(a, id_closed, 0, 0);
+	    if (RTEST(iv)) {
+		rb_raise(rb_eArgError, "closed object");
+	    }
+	}
+	bziv = bz_find_struct(a, 0, 0);
+	if (bziv) {
+	    if (RTEST(bziv->bz2)) {
+		rb_raise(rb_eArgError, "invalid data type");
+	    }
+	    bziv->bz2 = obj;
+	}
+	else {
+	    iv = Data_Make_Struct(rb_cData, struct bz_iv, 0, free, bziv);
+	    bziv->io = a;
+	    bziv->bz2 = obj;
+	    rb_ary_push(bz_internal_ary, iv);
+	}
+	switch (TYPE(a)) {
+	case T_FILE:
+	    bziv->finalize = RFILE(a)->fptr->finalize;
+	    RFILE(a)->fptr->finalize = bz_io_data_finalize;
+	    break;
+	case T_DATA:
+	    bziv->finalize = RDATA(a)->dfree;
+	    RDATA(a)->dfree = bz_io_data_finalize;
+	    break;
+	}
+    }
+    bzf->io = a;
+    bzf->blocks = blocks;
+    bzf->work = work;
+    return obj;
+}
+
+#define BZ_RB_BLOCKSIZE 4096
+
+static VALUE
+bz_writer_write(obj, a)
+    VALUE obj, a;
+{
+    struct bz_file *bzf;
+    int n;
+
+    a = rb_obj_as_string(a);
+    Get_BZ2(obj, bzf);
+    if (!bzf->buf) {
+	if (bzf->state != BZ_OK) {
+	    bz_raise(bzf->state);
+	}
+	bzf->state = BZ2_bzCompressInit(&(bzf->bzs), bzf->blocks,
+					0, bzf->work);
+	if (bzf->state != BZ_OK) {
+	    bz_writer_internal_flush(bzf);
+	    bz_raise(bzf->state);
+	}
+	bzf->buf = ALLOC_N(char, BZ_RB_BLOCKSIZE + 1);
+	bzf->buflen = BZ_RB_BLOCKSIZE;
+	bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
+    }
+    bzf->bzs.next_in = RSTRING_PTR(a);
+    bzf->bzs.avail_in = RSTRING_LEN(a);
+    while (bzf->bzs.avail_in) {
+	bzf->bzs.next_out = bzf->buf;
+	bzf->bzs.avail_out = bzf->buflen;
+	bzf->state = BZ2_bzCompress(&(bzf->bzs), BZ_RUN);
+	if (bzf->state == BZ_SEQUENCE_ERROR || bzf->state == BZ_PARAM_ERROR) {
+	    bz_writer_internal_flush(bzf);
+	    bz_raise(bzf->state);
+	}
+	bzf->state = BZ_OK;
+	if (bzf->bzs.avail_out < bzf->buflen) {
+	    n = bzf->buflen - bzf->bzs.avail_out;
+	    rb_funcall(bzf->io, id_write, 1, rb_str_new(bzf->buf, n));
+	}
+    }
+    return INT2NUM(RSTRING_LEN(a));
+}
+
+static VALUE
+bz_writer_putc(obj, a)
+    VALUE obj, a;
+{
+    char c = NUM2CHR(a);
+    return bz_writer_write(obj, rb_str_new(&c, 1));
+}
+
+static VALUE
+bz_compress(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE bz2, str;
+
+    if (!argc) {
+	rb_raise(rb_eArgError, "need a String to compress");
+    }
+    str = rb_str_to_str(argv[0]);
+    argv[0] = Qnil;
+    bz2 = rb_funcall2(bz_cWriter, id_new, argc, argv);
+    if (OBJ_TAINTED(str)) {
+	struct bz_file *bzf;
+	Data_Get_Struct(bz2, struct bz_file, bzf);
+	OBJ_TAINT(bzf->io);
+    }
+    bz_writer_write(bz2, str);
+    return bz_writer_close(bz2);
+}
+
+static VALUE
+bz_reader_s_alloc(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE res;
+    res = Data_Make_Struct(obj, struct bz_file, bz_file_mark, 
+			   ruby_xfree, bzf);
+    bzf->bzs.bzalloc = bz_malloc;
+    bzf->bzs.bzfree = bz_free;
+    bzf->blocks = DEFAULT_BLOCKS;
+    bzf->state = BZ_OK;
+    return res;
+}
+
+static VALUE bz_reader_close __((VALUE));
+
+static VALUE
+bz_reader_s_open(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE res;
+    struct bz_file *bzf;
+
+    if (argc < 1) {
+	rb_raise(rb_eArgError, "invalid number of arguments");
+    }
+    argv[0] = rb_funcall2(rb_mKernel, id_open, 1, argv);
+    if (NIL_P(argv[0])) return Qnil;
+    res = rb_funcall2(obj, id_new, argc, argv);
+    Data_Get_Struct(res, struct bz_file, bzf);
+    bzf->flags |= BZ2_RB_CLOSE;
+    if (rb_block_given_p()) {
+	return rb_ensure(rb_yield, res, bz_reader_close, res);
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_init(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    struct bz_file *bzf;
+    int small = 0;
+    VALUE a, b;
+    int internal = 0;
+
+    if (rb_scan_args(argc, argv, "11", &a, &b) == 2) {
+	small = RTEST(b);
+    }
+    rb_io_taint_check(a);
+    if (OBJ_TAINTED(a)) {
+	OBJ_TAINT(obj);
+    }
+    if (rb_respond_to(a, id_read)) {
+	if (TYPE(a) == T_FILE) {
+	    OpenFile *fptr;
+
+	    GetOpenFile(a, fptr);
+	    rb_io_check_readable(fptr);
+	}
+	else if (rb_respond_to(a, id_closed)) {
+	    VALUE iv = rb_funcall2(a, id_closed, 0, 0);
+	    if (RTEST(iv)) {
+		rb_raise(rb_eArgError, "closed object");
+	    }
+	}
+    }
+    else {
+	struct bz_str *bzs;
+	VALUE res;
+
+	if (!rb_respond_to(a, id_str)) {
+	    rb_raise(rb_eArgError, "first argument must respond to #read");
+	}
+	a = rb_funcall2(a, id_str, 0, 0);
+	if (TYPE(a) != T_STRING) {
+	    rb_raise(rb_eArgError, "#to_str must return a String");
+	}
+	res = Data_Make_Struct(bz_cInternal, struct bz_str, 
+			       bz_str_mark, ruby_xfree, bzs);
+	bzs->str = a;
+	a = res;
+	internal = BZ2_RB_INTERNAL;
+    }
+    Data_Get_Struct(obj, struct bz_file, bzf);
+    bzf->io = a;
+    bzf->small = small;
+    bzf->flags |= internal;
+    return obj;
+}
+
+static struct bz_file *
+bz_get_bzf(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    if (!bzf->buf) {
+	if (bzf->state != BZ_OK) {
+	    bz_raise(bzf->state);
+	}
+	bzf->state = BZ2_bzDecompressInit(&(bzf->bzs), 0, bzf->small);
+	if (bzf->state != BZ_OK) {
+	    BZ2_bzDecompressEnd(&(bzf->bzs));
+	    bz_raise(bzf->state);
+	}
+	bzf->buf = ALLOC_N(char, BZ_RB_BLOCKSIZE + 1);
+	bzf->buflen = BZ_RB_BLOCKSIZE;
+	bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
+	bzf->bzs.total_out_hi32 = bzf->bzs.total_out_lo32 = 0;
+	bzf->bzs.next_out = bzf->buf;
+	bzf->bzs.avail_out = 0;
+    }
+    if (bzf->state == BZ_STREAM_END && !bzf->bzs.avail_out) {
+	return 0;
+    }
+    return bzf;
+}
+
+static int
+bz_next_available(bzf, in)
+    struct bz_file *bzf;
+    int in;
+{
+    bzf->bzs.next_out = bzf->buf;
+    bzf->bzs.avail_out = 0;
+    if (bzf->state == BZ_STREAM_END) {
+	return BZ_STREAM_END;
+    }
+    if (!bzf->bzs.avail_in) {
+	bzf->in = rb_funcall(bzf->io, id_read, 1, INT2FIX(1024));
+	if (TYPE(bzf->in) != T_STRING || RSTRING_LEN(bzf->in) == 0) {
+	    BZ2_bzDecompressEnd(&(bzf->bzs));
+	    bzf->bzs.avail_out = 0;
+	    bzf->state = BZ_UNEXPECTED_EOF;
+	    bz_raise(bzf->state);
+	}
+	bzf->bzs.next_in = RSTRING_PTR(bzf->in);
+	bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
+    }
+    if ((bzf->buflen - in) < (BZ_RB_BLOCKSIZE / 2)) {
+	bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen+BZ_RB_BLOCKSIZE+1);
+	bzf->buflen += BZ_RB_BLOCKSIZE;
+	bzf->buf[bzf->buflen] = '\0';
+    }
+    bzf->bzs.avail_out = bzf->buflen - in;
+    bzf->bzs.next_out = bzf->buf + in;
+    bzf->state = BZ2_bzDecompress(&(bzf->bzs));
+    if (bzf->state != BZ_OK) {
+	BZ2_bzDecompressEnd(&(bzf->bzs));
+	if (bzf->state != BZ_STREAM_END) {
+	    bzf->bzs.avail_out = 0;
+	    bz_raise(bzf->state);
+	}
+    }
+    bzf->bzs.avail_out = bzf->buflen - bzf->bzs.avail_out;
+    bzf->bzs.next_out = bzf->buf;
+    return 0;
+}
+
+#define ASIZE (1 << CHAR_BIT)
+
+static VALUE
+bz_read_until(bzf, str, len, td1)
+    struct bz_file *bzf;
+    char *str;
+    int len;
+    int *td1;
+{
+    VALUE res;
+    int total, i, nex = 0;
+    char *p, *t, *tx, *end, *pend = str + len;
+
+    res = rb_str_new(0, 0);
+    while (1) {
+	total = bzf->bzs.avail_out;
+	if (len == 1) {
+	    tx = memchr(bzf->bzs.next_out, *str, bzf->bzs.avail_out);
+	    if (tx) {
+		i = tx - bzf->bzs.next_out + len;
+		res = rb_str_cat(res, bzf->bzs.next_out, i);
+		bzf->bzs.next_out += i;
+		bzf->bzs.avail_out -= i;
+		return res;
+	    }
+	}
+	else {
+	    tx = bzf->bzs.next_out;
+	    end = bzf->bzs.next_out + bzf->bzs.avail_out;
+	    while (tx + len <= end) {
+		for (p = str, t = tx; p != pend; ++p, ++t) {
+		    if (*p != *t) break;
+		}
+		if (p == pend) {
+		    i = tx - bzf->bzs.next_out + len;
+		    res = rb_str_cat(res, bzf->bzs.next_out, i);
+		    bzf->bzs.next_out += i;
+		    bzf->bzs.avail_out -= i;
+		    return res;
+		}
+		if (td1) {
+		    tx += td1[(int)*(tx + len)];
+		}
+		else {
+		    tx += 1;
+		}
+	    }
+	}
+	nex = 0;
+	if (total) {
+	    nex = len - 1;
+	    res = rb_str_cat(res, bzf->bzs.next_out, total - nex);
+	    if (nex) {
+		MEMMOVE(bzf->buf, bzf->bzs.next_out + total - nex, char, nex);
+	    }
+	}
+	if (bz_next_available(bzf, nex) == BZ_STREAM_END) {
+	    if (nex) {
+		res = rb_str_cat(res, bzf->buf, nex);
+	    }
+	    if (RSTRING_LEN(res)) {
+		return res;
+	    }
+	    return Qnil;
+	}
+    }
+    return Qnil;
+}
+
+static int
+bz_read_while(bzf, c)
+    struct bz_file *bzf;
+    char c;
+{
+    char *end;
+
+    while (1) {
+	end = bzf->bzs.next_out + bzf->bzs.avail_out;
+	while (bzf->bzs.next_out < end) {
+	    if (c != *bzf->bzs.next_out) {
+		bzf->bzs.avail_out = end -  bzf->bzs.next_out;
+		return *bzf->bzs.next_out;
+	    }
+	    ++bzf->bzs.next_out;
+	}
+	if (bz_next_available(bzf, 0) == BZ_STREAM_END) {
+	    return EOF;
+	}
+    }
+    return EOF;
+}
+
+static VALUE
+bz_reader_read(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    struct bz_file *bzf;
+    VALUE res, length;
+    int total;
+    int n;
+
+    rb_scan_args(argc, argv, "01", &length);
+    if (NIL_P(length)) {
+	n = -1;
+    }
+    else {
+	n = NUM2INT(length);
+	if (n < 0) {
+	    rb_raise(rb_eArgError, "negative length %d given", n);
+	}
+    }
+    bzf = bz_get_bzf(obj);
+    if (!bzf) {
+	return Qnil;
+    }
+    res = rb_str_new(0, 0);
+    if (OBJ_TAINTED(obj)) {
+	OBJ_TAINT(res);
+    }
+    if (n == 0) {
+	return res;
+    }
+    while (1) {
+	total = bzf->bzs.avail_out;
+	if (n != -1 && (RSTRING_LEN(res) + total) >= n) {
+	    n -= RSTRING_LEN(res);
+	    res = rb_str_cat(res, bzf->bzs.next_out, n);
+	    bzf->bzs.next_out += n;
+	    bzf->bzs.avail_out -= n;
+	    return res;
+	}
+	if (total) {
+	    res = rb_str_cat(res, bzf->bzs.next_out, total);
+	}
+	if (bz_next_available(bzf, 0) == BZ_STREAM_END) {
+	    return res;
+	}
+    }
+    return Qnil;
+}
+
+static int
+bz_getc(obj)
+    VALUE obj;
+{
+    VALUE length = INT2FIX(1);
+    VALUE res = bz_reader_read(1, &length, obj);
+    if (NIL_P(res) || RSTRING_LEN(res) == 0) {
+	return EOF;
+    }
+    return RSTRING_PTR(res)[0];
+}
+
+static VALUE
+bz_reader_ungetc(obj, a)
+    VALUE obj, a;
+{
+    struct bz_file *bzf;
+    int c = NUM2INT(a);
+
+    Get_BZ2(obj, bzf);
+    if (!bzf->buf) {
+	bz_raise(BZ_SEQUENCE_ERROR);
+    }
+    if (bzf->bzs.avail_out < bzf->buflen) {
+	bzf->bzs.next_out -= 1;
+	bzf->bzs.next_out[0] = c;
+	bzf->bzs.avail_out += 1;
+    }
+    else {
+	bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + 2);
+	bzf->buf[bzf->buflen++] = c;
+	bzf->buf[bzf->buflen] = '\0';
+	bzf->bzs.next_out = bzf->buf;
+	bzf->bzs.avail_out = bzf->buflen;
+    }
+    return Qnil;
+}
+
+static VALUE
+bz_reader_ungets(obj, a)
+    VALUE obj, a;
+{
+    struct bz_file *bzf;
+
+    Check_Type(a, T_STRING);
+    Get_BZ2(obj, bzf);
+    if (!bzf->buf) {
+	bz_raise(BZ_SEQUENCE_ERROR);
+    }
+    if ((bzf->bzs.avail_out + RSTRING_LEN(a)) < bzf->buflen) {
+	bzf->bzs.next_out -= RSTRING_LEN(a);
+	MEMCPY(bzf->bzs.next_out, RSTRING_PTR(a), char, RSTRING_LEN(a));
+	bzf->bzs.avail_out += RSTRING_LEN(a);
+    }
+    else {
+	bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + RSTRING_LEN(a) + 1);
+	MEMCPY(bzf->buf + bzf->buflen, RSTRING_PTR(a), char,RSTRING_LEN(a));
+	bzf->buflen += RSTRING_LEN(a);
+	bzf->buf[bzf->buflen] = '\0';
+	bzf->bzs.next_out = bzf->buf;
+	bzf->bzs.avail_out = bzf->buflen;
+    }
+    return Qnil;
+}
+
+VALUE
+bz_reader_gets(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE str = Qnil;
+
+    bzf = bz_get_bzf(obj);
+    if (bzf) {
+	str = bz_read_until(bzf, "\n", 1, 0);
+	if (!NIL_P(str)) {
+	    bzf->lineno++;
+	    OBJ_TAINT(str);
+	}
+    }
+    return str;
+}
+
+static VALUE
+bz_reader_gets_internal(argc, argv, obj, td, init)
+    int argc;
+    VALUE obj, *argv;
+    int *td, init;
+{
+    struct bz_file *bzf;
+    VALUE rs, res;
+    char *rsptr;
+    int rslen, rspara, *td1;
+
+    rs = rb_rs;
+    if (argc) {
+	rb_scan_args(argc, argv, "1", &rs);
+	if (!NIL_P(rs)) {
+	    Check_Type(rs, T_STRING);
+	}
+    }
+    if (NIL_P(rs)) {
+	return bz_reader_read(1, &rs, obj);
+    }
+    rslen = RSTRING_LEN(rs);
+    if (rs == rb_default_rs || (rslen == 1 && RSTRING_PTR(rs)[0] == '\n')) {
+	return bz_reader_gets(obj);
+    }
+
+    if (rslen == 0) {
+	rsptr = "\n\n";
+	rslen = 2;
+	rspara = 1;
+    }
+    else {
+	rsptr = RSTRING_PTR(rs);
+	rspara = 0;
+    }
+
+    bzf = bz_get_bzf(obj);
+    if (!bzf) {
+	return Qnil;
+    }
+    if (rspara) {
+	bz_read_while(bzf, '\n');
+    }
+    td1 = 0;
+    if (rslen != 1) {
+	if (init) {
+	    int i;
+
+	    for (i = 0; i < ASIZE; i++) {
+		td[i] = rslen + 1;
+	    }
+	    for (i = 0; i < rslen; i++) {
+		td[(int)*(rsptr + i)] = rslen - i;
+	    }
+	}
+	td1 = td;
+    }
+
+    res = bz_read_until(bzf, rsptr, rslen, td1);
+    if (rspara) {
+	bz_read_while(bzf, '\n');
+    }
+
+    if (!NIL_P(res)) {
+	bzf->lineno++;
+	OBJ_TAINT(res);
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_set_unused(obj, a)
+    VALUE obj, a;
+{
+    struct bz_file *bzf;
+
+    Check_Type(a, T_STRING);
+    Get_BZ2(obj, bzf);
+    if (!bzf->in) {
+	bzf->in = rb_str_new(RSTRING_PTR(a), RSTRING_LEN(a));
+    }
+    else {
+	bzf->in = rb_str_cat(bzf->in, RSTRING_PTR(a), RSTRING_LEN(a));
+    }
+    bzf->bzs.next_in = RSTRING_PTR(bzf->in);
+    bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
+    return Qnil;
+}
+
+static VALUE
+bz_reader_getc(obj)
+    VALUE obj;
+{
+    VALUE str;
+    VALUE len = INT2FIX(1);
+
+    str = bz_reader_read(1, &len, obj);
+    if (NIL_P(str) || RSTRING_LEN(str) == 0) {
+	return Qnil;
+    }
+    return INT2FIX(RSTRING_PTR(str)[0] & 0xff);
+}
+
+static void
+bz_eoz_error()
+{
+    rb_raise(bz_eEOZError, "End of Zip component reached");
+}
+
+static VALUE
+bz_reader_readchar(obj)
+    VALUE obj;
+{
+    VALUE res = bz_reader_getc(obj);
+
+    if (NIL_P(res)) {
+	bz_eoz_error();
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_gets_m(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    int td[ASIZE];
+    VALUE str = bz_reader_gets_internal(argc, argv, obj, td, Qtrue);
+
+    if (!NIL_P(str)) {
+	rb_lastline_set(str);
+    }
+    return str;
+}
+
+static VALUE
+bz_reader_readline(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE res = bz_reader_gets_m(argc, argv, obj);
+
+    if (NIL_P(res)) {
+	bz_eoz_error();
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_readlines(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE line, ary;
+    int td[ASIZE], in;
+
+    in = Qtrue;
+    ary = rb_ary_new();
+    while (!NIL_P(line = bz_reader_gets_internal(argc, argv, obj, td, in))) {
+	in = Qfalse;
+	rb_ary_push(ary, line);
+    }
+    return ary;
+}
+
+static VALUE
+bz_reader_each_line(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE line;
+    int td[ASIZE], in;
+
+    in = Qtrue;
+    while (!NIL_P(line = bz_reader_gets_internal(argc, argv, obj, td, in))) {
+	in = Qfalse;
+	rb_yield(line);
+    }
+    return obj;
+}
+
+static VALUE
+bz_reader_each_byte(obj)
+    VALUE obj;
+{
+    int c;
+
+    while ((c = bz_getc(obj)) != EOF) {
+	rb_yield(INT2FIX(c & 0xff));
+    }
+    return obj;
+}
+
+static VALUE
+bz_reader_unused(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE res;
+
+    Get_BZ2(obj, bzf);
+    if (!bzf->in || bzf->state != BZ_STREAM_END) {
+	return Qnil;
+    }
+    if (bzf->bzs.avail_in) {
+	res = rb_tainted_str_new(bzf->bzs.next_in, bzf->bzs.avail_in);
+	bzf->bzs.avail_in = 0;
+    }
+    else {
+	res = rb_tainted_str_new(0, 0);
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_eoz(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    if (!bzf->in || !bzf->buf) {
+	return Qnil;
+    }
+    if (bzf->state == BZ_STREAM_END && !bzf->bzs.avail_out) {
+	return Qtrue;
+    }
+    return Qfalse;
+}
+
+static VALUE
+bz_reader_eof(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE res;
+
+    res = bz_reader_eoz(obj);
+    if (RTEST(res)) {
+	Get_BZ2(obj, bzf);
+	if (bzf->bzs.avail_in) {
+	    res = Qfalse;
+	}
+	else {
+	    res = bz_reader_getc(obj);
+	    if (NIL_P(res)) {
+		res = Qtrue;
+	    }
+	    else {
+		bz_reader_ungetc(res);
+		res = Qfalse;
+	    }
+	}
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_closed(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Data_Get_Struct(obj, struct bz_file, bzf);
+    return RTEST(bzf->io)?Qfalse:Qtrue;
+}
+
+static VALUE
+bz_reader_close(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    VALUE res;
+
+    Get_BZ2(obj, bzf);
+    if (bzf->buf) {
+	free(bzf->buf);
+	bzf->buf = 0;
+    }
+    if (bzf->state == BZ_OK) {
+	BZ2_bzDecompressEnd(&(bzf->bzs));
+    }
+    if (bzf->flags & BZ2_RB_CLOSE) {
+	int closed = 0;
+	if (rb_respond_to(bzf->io, id_closed)) {
+	    VALUE iv = rb_funcall2(bzf->io, id_closed, 0, 0);
+	    closed = RTEST(iv);
+	}
+	if (!closed && rb_respond_to(bzf->io, id_close)) {
+	    rb_funcall2(bzf->io, id_close, 0, 0);
+	}
+    }
+    if (bzf->flags & (BZ2_RB_CLOSE|BZ2_RB_INTERNAL)) {
+	res = Qnil;
+    }
+    else {
+	res = bzf->io;
+    }
+    bzf->io = 0;
+    return res;
+}
+
+static VALUE
+bz_reader_finish(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    if (bzf->buf) {
+	rb_funcall2(obj, id_read, 0, 0);
+	free(bzf->buf);
+    }
+    bzf->buf = 0;
+    bzf->state = BZ_OK;
+    return Qnil;
+}
+
+static VALUE
+bz_reader_close_bang(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+    int closed;
+
+    Get_BZ2(obj, bzf);
+    closed = bzf->flags & (BZ2_RB_CLOSE|BZ2_RB_INTERNAL);
+    bz_reader_close(obj);
+    if (!closed && rb_respond_to(bzf->io, id_close)) {
+	if (rb_respond_to(bzf->io, id_closed)) {
+	    closed = RTEST(rb_funcall2(bzf->io, id_closed, 0, 0));
+	}
+	if (!closed) {
+	    rb_funcall2(bzf->io, id_close, 0, 0);
+	}
+    }
+    return Qnil;
+}
+
+struct foreach_arg {
+    int argc;
+    VALUE sep;
+    VALUE obj;
+};
+
+static VALUE
+bz_reader_foreach_line(arg)
+    struct foreach_arg *arg;
+{
+    VALUE str;
+    int td[ASIZE], in;
+
+    in = Qtrue;
+    while (!NIL_P(str = bz_reader_gets_internal(arg->argc, &arg->sep,
+						arg->obj, td, in))) {
+	in = Qfalse;
+	rb_yield(str);
+    }
+    return Qnil;
+}
+
+static VALUE
+bz_reader_s_foreach(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE fname, sep;
+    struct foreach_arg arg;
+    struct bz_file *bzf;
+
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "call out of a block");
+    }
+    rb_scan_args(argc, argv, "11", &fname, &sep);
+    Check_SafeStr(fname);
+    arg.argc = argc - 1;
+    arg.sep = sep;
+    arg.obj = rb_funcall2(rb_mKernel, id_open, 1, &fname);
+    if (NIL_P(arg.obj)) return Qnil;
+    arg.obj = rb_funcall2(obj, id_new, 1, &arg.obj);
+    Data_Get_Struct(arg.obj, struct bz_file, bzf);
+    bzf->flags |= BZ2_RB_CLOSE;
+    return rb_ensure(bz_reader_foreach_line, (VALUE)&arg, bz_reader_close, arg.obj);
+}
+
+static VALUE
+bz_reader_i_readlines(arg)
+    struct foreach_arg *arg;
+{
+    VALUE str, res;
+    int td[ASIZE], in;
+
+    in = Qtrue;
+    res = rb_ary_new();
+    while (!NIL_P(str = bz_reader_gets_internal(arg->argc, &arg->sep,
+						arg->obj, td, in))) {
+	in = Qfalse;
+	rb_ary_push(res, str);
+    }
+    return res;
+}
+
+static VALUE
+bz_reader_s_readlines(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE fname, sep;
+    struct foreach_arg arg;
+    struct bz_file *bzf;
+
+    rb_scan_args(argc, argv, "11", &fname, &sep);
+    Check_SafeStr(fname);
+    arg.argc = argc - 1;
+    arg.sep = sep;
+    arg.obj = rb_funcall2(rb_mKernel, id_open, 1, &fname);
+    if (NIL_P(arg.obj)) return Qnil;
+    arg.obj = rb_funcall2(obj, id_new, 1, &arg.obj);
+    Data_Get_Struct(arg.obj, struct bz_file, bzf);
+    bzf->flags |= BZ2_RB_CLOSE;
+    return rb_ensure(bz_reader_i_readlines, (VALUE)&arg, bz_reader_close, arg.obj);
+}
+
+static VALUE
+bz_reader_lineno(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    return INT2NUM(bzf->lineno);
+}
+
+static VALUE
+bz_reader_set_lineno(obj, lineno)
+    VALUE obj, lineno;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    bzf->lineno = NUM2INT(lineno);
+    return lineno;
+}
+
+static VALUE
+bz_to_io(obj)
+    VALUE obj;
+{
+    struct bz_file *bzf;
+
+    Get_BZ2(obj, bzf);
+    return bzf->io;
+}
+
+static VALUE
+bz_str_read(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    struct bz_str *bzs;
+    VALUE res, len;
+    int count;
+    
+    Data_Get_Struct(obj, struct bz_str, bzs);
+    rb_scan_args(argc, argv, "01", &len);
+    if (NIL_P(len)) {
+	count = RSTRING_LEN(bzs->str);
+    }
+    else {
+	count = NUM2INT(len);
+	if (count < 0) {
+	    rb_raise(rb_eArgError, "negative length %d given", count);
+	}
+    }
+    if (!count || bzs->pos == -1) {
+	return Qnil;
+    }
+    if ((bzs->pos + count) >= RSTRING_LEN(bzs->str)) {
+	res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, 
+			 RSTRING_LEN(bzs->str) - bzs->pos);
+	bzs->pos = -1;
+    }
+    else {
+	res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, count);
+	bzs->pos += count;
+    }
+    return res;
+}
+
+static VALUE
+bz_uncompress(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE bz2, nilv = Qnil;
+
+    if (!argc) {
+	rb_raise(rb_eArgError, "need a String to Uncompress");
+    }
+    argv[0] = rb_str_to_str(argv[0]);
+    bz2 = rb_funcall2(bz_cReader, id_new, argc, argv);
+    return bz_reader_read(1, &nilv, bz2);
+}
+
+static VALUE
+bz_s_new(argc, argv, obj)
+    int argc;
+    VALUE obj, *argv;
+{
+    VALUE res = rb_funcall2(obj, rb_intern("allocate"), 0, 0);
+    rb_obj_call_init(res, argc, argv);
+    return res;
+}
+
+static VALUE
+bz_proc_new(func, val)
+    VALUE (*func)(ANYARGS);
+    VALUE val;
+{
+    VALUE tmp = Data_Wrap_Struct(rb_cData, 0, 0, 0);
+    rb_define_singleton_method(tmp, "tmp_proc", func, 1);
+    return rb_funcall2(rb_funcall(tmp, rb_intern("method"), 1, 
+                                  ID2SYM(rb_intern("tmp_proc"))),
+                       rb_intern("to_proc"), 0, 0);
+}
+
+void Init_bz2()
+{
+    VALUE bz_mBZ2;
+
+    if (rb_const_defined_at(rb_cObject, rb_intern("BZ2"))) {
+	rb_raise(rb_eNameError, "module already defined");
+    }
+
+    bz_internal_ary = rb_ary_new();
+    rb_global_variable(&bz_internal_ary);
+    rb_funcall(rb_const_get(rb_cObject, rb_intern("ObjectSpace")), 
+	       rb_intern("define_finalizer"), 2, bz_internal_ary,
+	       bz_proc_new(bz_internal_finalize, 0));
+
+    id_new = rb_intern("new");
+    id_write = rb_intern("write");
+    id_open = rb_intern("open");
+    id_flush = rb_intern("flush");
+    id_read = rb_intern("read");
+    id_close = rb_intern("close");
+    id_closed = rb_intern("closed?");
+    id_str = rb_intern("to_str");
+
+    bz_mBZ2 = rb_define_module("BZ2");
+    bz_eConfigError = rb_define_class_under(bz_mBZ2, "ConfigError", rb_eFatal);
+    bz_eError = rb_define_class_under(bz_mBZ2, "Error", rb_eIOError);
+    bz_eEOZError = rb_define_class_under(bz_mBZ2, "EOZError", bz_eError);
+
+    rb_define_module_function(bz_mBZ2, "compress", bz_compress, -1);
+    rb_define_module_function(bz_mBZ2, "uncompress", bz_uncompress, -1);
+    rb_define_module_function(bz_mBZ2, "decompress", bz_uncompress, -1);
+    rb_define_module_function(bz_mBZ2, "bzip2", bz_compress, -1);
+    rb_define_module_function(bz_mBZ2, "bunzip2", bz_uncompress, -1);
+    /*
+      Writer
+    */
+    bz_cWriter = rb_define_class_under(bz_mBZ2, "Writer", rb_cData);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_define_alloc_func(bz_cWriter, bz_writer_s_alloc);
+#else
+    rb_define_singleton_method(bz_cWriter, "allocate", bz_writer_s_alloc, 0);
+#endif    
+    rb_define_singleton_method(bz_cWriter, "new", bz_s_new, -1);
+    rb_define_singleton_method(bz_cWriter, "open", bz_writer_s_open, -1);
+    rb_define_method(bz_cWriter, "initialize", bz_writer_init, -1);
+    rb_define_method(bz_cWriter, "write", bz_writer_write, 1);
+    rb_define_method(bz_cWriter, "putc", bz_writer_putc, 1);
+    rb_define_method(bz_cWriter, "puts", rb_io_puts, -1);
+    rb_define_method(bz_cWriter, "print", rb_io_print, -1);
+    rb_define_method(bz_cWriter, "printf", rb_io_printf, -1);
+    rb_define_method(bz_cWriter, "<<", rb_io_addstr, 1);
+    rb_define_method(bz_cWriter, "flush", bz_writer_flush, 0);
+    rb_define_method(bz_cWriter, "finish", bz_writer_flush, 0);
+    rb_define_method(bz_cWriter, "close", bz_writer_close, 0);
+    rb_define_method(bz_cWriter, "close!", bz_writer_close_bang, 0);
+    rb_define_method(bz_cWriter, "to_io", bz_to_io, 0);
+    /*
+      Reader
+    */
+    bz_cReader = rb_define_class_under(bz_mBZ2, "Reader", rb_cData);
+    rb_include_module(bz_cReader, rb_mEnumerable);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_define_alloc_func(bz_cReader, bz_reader_s_alloc);
+#else
+    rb_define_singleton_method(bz_cReader, "allocate", bz_reader_s_alloc, 0);
+#endif
+    rb_define_singleton_method(bz_cReader, "new", bz_s_new, -1);
+    rb_define_singleton_method(bz_cReader, "open", bz_reader_s_open, -1);
+    rb_define_singleton_method(bz_cReader, "foreach", bz_reader_s_foreach, -1);
+    rb_define_singleton_method(bz_cReader, "readlines", bz_reader_s_readlines, -1);
+    rb_define_method(bz_cReader, "initialize", bz_reader_init, -1);
+    rb_define_method(bz_cReader, "read", bz_reader_read, -1);
+    rb_define_method(bz_cReader, "unused", bz_reader_unused, 0);
+    rb_define_method(bz_cReader, "unused=", bz_reader_set_unused, 1);
+    rb_define_method(bz_cReader, "ungetc", bz_reader_ungetc, 1);
+    rb_define_method(bz_cReader, "ungets", bz_reader_ungets, 1);
+    rb_define_method(bz_cReader, "getc", bz_reader_getc, 0);
+    rb_define_method(bz_cReader, "gets", bz_reader_gets_m, -1);
+    rb_define_method(bz_cReader, "readchar", bz_reader_readchar, 0);
+    rb_define_method(bz_cReader, "readline", bz_reader_readline, -1);
+    rb_define_method(bz_cReader, "readlines", bz_reader_readlines, -1);
+    rb_define_method(bz_cReader, "each", bz_reader_each_line, -1);
+    rb_define_method(bz_cReader, "each_line", bz_reader_each_line, -1);
+    rb_define_method(bz_cReader, "each_byte", bz_reader_each_byte, 0);
+    rb_define_method(bz_cReader, "close", bz_reader_close, 0);
+    rb_define_method(bz_cReader, "close!", bz_reader_close_bang, 0);
+    rb_define_method(bz_cReader, "finish", bz_reader_finish, 0);
+    rb_define_method(bz_cReader, "closed", bz_reader_closed, 0);
+    rb_define_method(bz_cReader, "closed?", bz_reader_closed, 0);
+    rb_define_method(bz_cReader, "eoz?", bz_reader_eoz, 0);
+    rb_define_method(bz_cReader, "eoz", bz_reader_eoz, 0);
+    rb_define_method(bz_cReader, "eof?", bz_reader_eof, 0);
+    rb_define_method(bz_cReader, "eof", bz_reader_eof, 0);
+    rb_define_method(bz_cReader, "lineno", bz_reader_lineno, 0);
+    rb_define_method(bz_cReader, "lineno=", bz_reader_set_lineno, 1);
+    rb_define_method(bz_cReader, "to_io", bz_to_io, 0);
+    /*
+      Internal
+    */
+    bz_cInternal = rb_define_class_under(bz_mBZ2, "InternalStr", rb_cData);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_undef_alloc_func(bz_cInternal);
+#else
+    rb_undef_method(CLASS_OF(bz_cInternal), "allocate");
+#endif
+    rb_undef_method(CLASS_OF(bz_cInternal), "new");
+    rb_undef_method(bz_cInternal, "initialize");
+    rb_define_method(bz_cInternal, "read", bz_str_read, -1);
+}