=begin
#
# zlib.rd.src
#
#   Copyright (C) UENO Katsuhiro 2000-2003
#
# $Id: zlib.rd.src,v 1.7 2003/03/28 02:08:28 katsu Exp $
#

= Ruby/zlib version 0.6.0

Ruby/zlib は zlib を Ruby から使うための拡張ライブラリです。
gzip ファイルの読み書きもサポートします。

	en| Ruby/zlib is an extension library to use zlib from Ruby.
	en| Ruby/zlib also provides the features for accessing gzipped files.

Ruby/zlib は Ruby と同じ条件で変更/配布することができます。
Ruby/zlib の最新版は ((<URL:http://www.blue.sky.or.jp/>)) から
入手できます。

	en| You can modify or redistribute Ruby/zlib in the same manner of
	en| Ruby interpreter. The latest version of Ruby/zlib would be found
	en| at ((<URL:http://www.blue.sky.or.jp/>)).

Ruby/zlib に対するご意見、バグレポート等は ruby-list ML, ruby-dev ML,
ruby-ext ML, ruby-talk ML, 又は ((<URL:mailto:katsu@blue.sky.or.jp>))
までお願いします。

	en| Any comments and suggestions are always welcome. Please send
	en| them to ruby-list ML, ruby-ext ML, ruby-talk ML, or the author's
	en| mail address ((<URL:mailto:katsu@blue.sky.or.jp>)).
	en|
	en| This document is experimental and broken English version.
	en| If you find some mistakes or strange expressions (including
	en| kidding or unnatural ones) in this document, please let me know
	en| for my study.

* ((<Zlib>))

  * ((<Zlib::Error>))
  * ((<Zlib::ZStream>))
  * ((<Zlib::Deflate>))
  * ((<Zlib::Inflate>))
  * ((<Zlib::GzipFile>))
  * ((<Zlib::GzipFile::Error>))
  * ((<Zlib::GzipWriter>))
  * ((<Zlib::GzipReader>))

* ((<0.5 から 0.6 への変更点>))
* ((<0.4 から 0.5 への変更点>))

	en| * ((<Changes from 0.5 to 0.6>))
	en| * ((<Changes from 0.4 to 0.5>))

== Zlib

zlib ライブラリに含まれている雑多な機能を提供するモジュール。
各モジュール関数の詳細は zlib.h を参照して下さい。

	en| Zlib is the module which provides the other features in zlib C
	en| library. See zlib.h for detail of each module function.

=== モジュール関数:
	en| === Module Functions:

--- Zlib.zlib_version

    zlib ライブラリのバージョンを表す文字列を返します。

	en| Returns the string which represents the version of zlib
	en| library.

--- Zlib.adler32([string[, adler]])

    ((|string|)) の Adler-32 チェックサムを計算し、((|adler|)) を
    更新した値を返します。((|string|)) が省略された場合は
    Adler-32 チェックサムの初期値を返します。((|adler|)) が
    省略された場合は ((|adler|)) に初期値が与えらたものとして
    計算します。

	en| Calculates Alder-32 checksum for ((|string|)),
	en| and returns updated value of ((|alder|)).
	en| If ((|string|)) is omitted, it returns the Adler-32 initial
	en| value. If ((|alder|)) is omitted, it assumes that the initial
	en| value is given to ((|alder|)).

--- Zlib.crc32([string[, crc]])

    ((|string|)) の CRC チェックサムを計算し、((|crc|)) を
    更新した値を返します。((|string|)) が省略された場合は
    CRC チェックサムの初期値を返します。((|crc|)) が
    省略された場合は ((|crc|)) に初期値が与えらたものとして
    計算します。

	en| Calculates CRC checksum for ((|string|)), and returns
	en| updated value of ((|crc|)). If ((|string|)) is omitted,
	en| it returns the CRC initial value. ((|crc|)) is omitted,
	en| it assumes that the initial value is given to ((|crc|)).

--- Zlib.crc_table

    CRC チェックサムの計算に用いるテーブルを配列で返します。

	en| Returns the table for calculating CRC checksum as an array.

=== 定数:
	en| === Constants:

--- Zlib::VERSION

    Ruby/zlib のバージョンを表す文字列。

	en| The Ruby/zlib version string.

--- Zlib::ZLIB_VERSION

    zlib.h のバージョンを表す文字列。

	en| The string which represents the version of zlib.h.

--- Zlib::BINARY
--- Zlib::ASCII
--- Zlib::UNKNOWN

    ((<Zlib::ZStream#data_type>)) の返す、データタイプを表す整数。

	en| The integers representing data types which
	en| ((<Zlib::ZStream#data_type>)) method returns.

--- Zlib::NO_COMPRESSION
--- Zlib::BEST_SPEED
--- Zlib::BEST_COMPRESSION
--- Zlib::DEFAULT_COMPRESSION

    ((<Zlib::Deflate.new>)) や ((<Zlib::Deflate#deflate>)) 等に渡す、
    圧縮レベルを表す整数。

	en| The integers representing compression levels which are
	en| an argument for ((<Zlib::Deflate.new>)),
	en| ((<Zlib::Deflate#deflate>)), and so on.

--- Zlib::FILTERED
--- Zlib::HUFFMAN_ONLY
--- Zlib::DEFAULT_STRATEGY

    ((<Zlib::Deflate.new>)) や ((<Zlib::Deflate#params>)) に渡す、
    圧縮方法を表す整数。

	en| The integers representing compression methods which are
	en| an argument for ((<Zlib::Deflate.new>)) and
	en| ((<Zlib::Deflate#params>)).

--- Zlib::DEF_MEM_LEVEL
--- Zlib::MAX_MEM_LEVEL

    ((<Zlib::Deflate.new>)) 等に渡す、memory level を表す整数。

	en| The integers representing memory levels which are an
	en| argument for ((<Zlib::Deflate.new>)),
	en| ((<Zlib::Deflate#params>)), and so on.

--- Zlib::MAX_WBITS

    ((<Zlib::Deflate.new>)) や ((<Zlib::Inflate.new>)) での
    ((|windowBits|)) のデフォルト値。

        en| The default value of ((|windowBits|)) which is an argument for
        en| ((<Zlib::Deflate.new>)) and ((<Zlib::Inflate.new>)).

--- Zlib::NO_FLUSH
--- Zlib::SYNC_FLUSH
--- Zlib::FULL_FLUSH
--- Zlib::FINISH

    ((<Zlib::Deflate#deflate>)) 等に渡す、ストリームの出力を
    制御するための整数。

	en| The integers to control the output of the deflate stream,
	en| which are an argument for ((<Zlib::Deflate#deflate>)) and so on.

--- Zlib::OS_CODE
--- Zlib::OS_MSDOS
--- Zlib::OS_AMIGA
--- Zlib::OS_VMS
--- Zlib::OS_UNIX
--- Zlib::OS_VMCMS
--- Zlib::OS_ATARI
--- Zlib::OS_OS2
--- Zlib::OS_MACOS
--- Zlib::OS_ZSYSTEM
--- Zlib::OS_CPM
--- Zlib::OS_TOPS20
--- Zlib::OS_WIN32
--- Zlib::OS_QDOS
--- Zlib::OS_RISCOS
--- Zlib::OS_UNKNOWN

    ((<Zlib::GzipFile#os_code>)) メソッドの返す値。

	en| The return values of ((<Zlib::GzipFile#os_code>)) method.


== Zlib::Error

Ruby/zlib の発行する全ての例外のスーパークラス。

	en| The superclass for all exceptions raised by Ruby/zlib.

以下の例外が Zlib::Error のサブクラスとして定義されています。
それぞれ zlib ライブラリ関数の返すエラーと対応しています。

	en| The following exceptions are defined as subclasses of Zlib::Error.
	en| These exceptions are raised when zlib library functions return
	en| with an error status.

  * Zlib::StreamEnd
  * Zlib::NeedDict
  * Zlib::DataError
  * Zlib::StreamError
  * Zlib::MemError
  * Zlib::BufError
  * Zlib::VersionError

=== スーパークラス:
	en| === SuperClass:

* StandardError


== Zlib::ZStream

圧縮データを扱うストリームを表す抽象クラス。
具体的な圧縮/展開の操作は、それぞれサブクラスの ((<Zlib::Deflate>)),
((<Zlib::Inflate>)) で定義されています。

	en| The abstract class for the stream which handles the compressed
	en| data. The operations are defined in the subclasses,
	en| ((<Zlib::Deflate>)) for compression, and ((<Zlib::Inflate>))
	en| for decompression.

Zlib::ZStream オブジェクトは、ストリーム (struct zstream) の
入力側 (next_in) と出力側 (next_out) にそれぞれ可変長の
バッファを持ちます。以下、入力側のバッファを「入力バッファ」、
出力側のバッファを「出力バッファ」と呼びます。

	en| An instance of Zlib::ZStream has one stream (struct zstream) and
	en| two variable-length buffers which associated to the input
	en| (next_in) of the stream and the output (next_out) of the stream.
	en| In this document, "input buffer" means the buffer for input, and
	en| "output buffer" means the buffer for output.

Zlib::ZStream オブジェクトに入力されたデータは、一旦入力バッファの
末尾にストアされた後、ストリームからの出力がなくなるまで
(処理後 avail_out > 0 となるまで) 入力バッファの先頭から順に処理されます。
処理の間、出力バッファは全出力を保持するために必要に応じて自動的に
確保・拡張されます。

	en| Data inputed into an instance of Zlib::ZStream are temporally
	en| stored into the end of input buffer, and then data in input buffer
	en| are processed from the beginning of the buffer until no more
	en| output from the stream is produced (i.e. until avail_out > 0
	en| after processing). During processing, output buffer is allocated
	en| and expanded automatically to hold all output data.

いくつかのメソッドは、出力バッファ内のデータを取り出し、
String オブジェクトとして返します。

	en| Some particular instance methods consume the data in output buffer
	en| and return them as a String.

以上を図示すると次のようになります:

	en| Here is an ascii art for describing above:

     +================ an instance of Zlib::ZStream ================+
     ||                                                            ||
     ||     +--------+          +-------+          +--------+      ||
     ||  +--| output |<---------|zstream|<---------| input  |<--+  ||
     ||  |  | buffer |  next_out+-------+next_in   | buffer |   |  ||
     ||  |  +--------+                             +--------+   |  ||
     ||  |                                                      |  ||
     +===|======================================================|===+
         |                                                      |
         v                                                      |
     "output data"                                         "input data"

入力バッファの内容を処理している最中にエラーが発生した場合、
((<Zlib::Error>)) のサブクラスの例外が発生します。その時、
入力/出力バッファは共に、エラーが発生した時点の状態をそのまま
保持します。

	en| If an error is occurred during processing input buffer,
	en| an exception which is a subclass of ((<Zlib::Error>)) is raised.
	en| At that time, both input and output buffer keeps their conditions
	en| at the time when the error is occurred.

=== スーパークラス:
	en| === SuperClass:

* Object

=== クラスメソッド:
	en| === Class Methods:

--- Zlib::ZStream.new

    ((<Zlib::Deflate.new>)) 及び ((<Zlib::Inflate.new>)) を参照。

	en| See ((<Zlib::Deflate.new>)) and ((<Zlib::Inflate.new>)).

=== メソッド:
	en| === Methods:

--- Zlib::ZStream#avail_in

    入力バッファに溜っているデータのバイト数を返します。通常は 0 です。

	en| Returns bytes of data in input buffer.
	en| Normally, returns 0.

--- Zlib::ZStream#avail_out

    出力バッファの空き用量をバイト数で返します。
    空きは必要な時に動的に確保されるため、通常は 0 です。

	en| Returns bytes of free spaces in output buffer.
	en| Because the free spaces are allocated automatically,
	en| this method returns 0 normally.

--- Zlib::ZStream#avail_out = size

    出力側のバッファに ((|size|)) バイトの空きを確保します。
    すでに ((|size|)) バイト以上の空きがある場合、バッファは
    縮められます。空きは必要な時に動的に確保されるため、通常
    このメソッドを使う必要はありません。

	en| Allocates free spaces of ((|size|)) bytes in output buffer.
	en| If there are more than ((|size|)) bytes spaces in the buffer,
	en| the buffer is truncated.
	en| Because the free spaces are allocated automatically,
	en| you usually need not to use this method.

--- Zlib::ZStream#flush_next_in

    入力バッファに残っているデータを強制的に取り出します。

	en| Flushes input buffer and returns all data in that buffer.

--- Zlib::ZStream#flush_next_out

    出力バッファに残っているデータを強制的に取り出します。

	en| Flushes output buffer and returns all data in that buffer.

--- Zlib::ZStream#total_in

    ストリームに入力されたデータの総バイト数を返します。

	en| Returns the total bytes of the input data to the stream.

--- Zlib::ZStream#total_out

    ストリームの出力したデータの総バイト数を返します。

	en| Returns the total bytes of the output data from the stream.

--- Zlib::ZStream#data_type

    ストリームに入力されたデータの形式を推測します。
    返り値は ((<Zlib::BINARY>)), ((<Zlib::ASCII>)), ((<Zlib::UNKNOWN>)) の
    いずれかです。

	en| Guesses the type of the data which have been inputed into
	en| the stream. The returned value is either ((<Zlib::BINARY>)),
	en| ((<Zlib::ASCII>)), or ((<Zlib::UNKNOWN>)).

--- Zlib::ZStream#adler

    alder-32 チェックサムを返します。

	en| Returns the alder-32 checksum.

--- Zlib::ZStream#reset

    ストリームの状態をリセットします。
    入力/出力バッファ内に残っていたデータは破棄されます。

	en| Resets and initializes the stream. All data in both
	en| input and output buffer are discarded.

--- Zlib::ZStream#finish

    ストリームへの入力を終了し、出力バッファをフラッシュします。
    より具体的な振る舞いは ((<Zlib::Deflate#finish>)),
    ((<Zlib::Inflate#finish>)) を参照して下さい。

	en| Finishes the stream and flushes output buffer.
	en| See ((<Zlib::Deflate#finish>)) and ((<Zlib::Inflate#finish>))
	en| for detail of the behavior.

--- Zlib::ZStream#finished?
--- Zlib::ZStream#stream_end?

    ストリームへの入力が終了している時に真を返します。

	en| Returns true if the stream is finished.

--- Zlib::ZStream#close
--- Zlib::ZStream#end

    ストリームを閉じます。
    以後、このストリームにアクセスすることはできなくなります。

	en| Closes the stream. All operations on the closed stream
	en| will raise an exception.

--- Zlib::ZStream#closed?
--- Zlib::ZStream#ended?

    ストリームが閉じられている時に真を返します。

	en| Returns true if the stream closed.


== Zlib::Deflate

入力データを圧縮するストリームのクラス。

	en| The class for compressing string data.

=== スーパークラス:
	en| === SuperClass:

* ((<Zlib::ZStream>))

=== クラスメソッド:
	en| === Class Methods:

--- Zlib::Deflate.deflate(string[, level])

    ((|string|)) を圧縮します。((|level|)) の有効な値は
    ((<Zlib::NO_COMPRESSION>)), ((<Zlib::BEST_SPEED>)),
    ((<Zlib::BEST_COMPRESSION>)), ((<Zlib::DEFAULT_COMPRESSION>))
    及び 0 から 9 の整数です。

	en| Compresses ((|string|)). The avail values of ((|level|)) are
	en| ((<Zlib::NO_COMPRESSION>)), ((<Zlib::BEST_SPEED>)),
	en| ((<Zlib::BEST_COMPRESSION>)), ((<Zlib::DEFAULT_COMPRESSION>)),
	en| and the integer from 0 to 9.

    ちなみに、このメソッドは以下のコードとほぼ同じです:

	en| This method is almost equivalent to the following code:

      def deflate(string, level)
        z = Zlib::Deflate.new(level)
        dst = z.deflate(string, Zlib::FINISH)
        z.close
        dst
      end

--- Zlib::Deflate.new([level[, windowBits[, memlevel[, strategy]]]])

    圧縮ストリームを作成します。各引数の詳細は zlib.h を
    参照して下さい。nil の場合はデフォルトの値を使用します。

	en| Creates a new deflate stream for compression.
	en| See zlib.h for details of each argument.
	en| If an argument is nil, the default value of that
	en| argument is used.

=== メソッド:
	en| === Methods:

--- Zlib::Deflate#clone

    圧縮ストリームを複製します。

	en| Duplicates the deflate stream.

--- Zlib::Deflate#deflate(string[, flush])

    ((|string|)) を圧縮ストリームに入力します。処理後、ストリームからの
    出力を返します。このメソッドを呼ぶと出力バッファ及び入力バッファは
    空になります。((|string|)) が nil の場合はストリームへの入力を
    終了します。(((<Zlib::ZStream#finish>)) と同じ)。
    ((|flush|)) には ((<Zlib::NO_FLUSH>)), ((<Zlib::SYNC_FLUSH>)),
    ((<Zlib::FULL_FLUSH>)), ((<Zlib::FINISH>)) のいずれかを指定します。
    詳しくは zlib.h を参照して下さい。

	en| Inputs ((|string|)) into the deflate stream and returns
	en| the output from the stream. Calling this method,
	en| both input and output buffer of the stream are flushed.
	en| If ((|string|)) is nil, this method finishes the stream,
	en| just like ((<Zlib::ZStream#finish>)).
	en| The value of ((|flush|)) should be either ((<Zlib::NO_FLUSH>)),
	en| ((<Zlib::SYNC_FLUSH>)), ((<Zlib::FULL_FLUSH>)), or
	en| ((<Zlib::FINISH>)).
	en| See zlib.h for details.

--- Zlib::Deflate#<< string

    ((<Zlib::Deflate#deflate>)) と同じように ((|string|)) を
    圧縮ストリームに入力しますが、Zlib::Deflate オブジェクト
    そのものを返します。圧縮ストリームからの出力は、
    出力バッファに保存されます。

	en| Inputs ((|string|)) into the deflate stream just like
	en| ((<Zlib::Deflate#deflate>)), but returns Zlib::Deflate object
	en| itself. The output from the stream is preserved in output
	en| buffer.

--- Zlib::Deflate#flush([flush])

    (({deflate('', ((|flush|)))})) と同じです。((|flush|)) が
    省略された時は ((<Zlib::SYNC_FLUSH>)) が使用されます。
    このメソッドはスクリプトの可読性のために提供されています。

	en| This method is equivalent to (({deflate('', ((|flush|)))})).
	en| If ((|flush|)) is omitted, ((<Zlib::SYNC_FLUSH>)) is used
	en| as ((|flush|)). This method is just provided for
	en| readability of your Ruby script.

--- Zlib::Deflate#finish

    圧縮ストリームを終了します。(({deflate('', Zlib::FINISH)})) と同じです。

	en| Finishes the stream. This method is equivalent to
	en| (({deflate('', Zlib::FINISH)})).

--- Zlib::Deflate#params(level, strategy)

    圧縮ストリームの設定を変更します。詳しくは zlib.h を
    参照して下さい。設定の変更に伴うストリームからの出力は
    出力バッファに保存されます。

	en| Changes the parameters of the deflate stream.
	en| See zlib.h for details. The output from the stream
	en| by changing the params is preserved in output buffer.

--- Zlib::Deflate#set_dictionary(string)

    圧縮に用いる辞書を指定します。((|string|)) を返します。
    このメソッドは ((<Zlib::Deflate.new>)), ((<Zlib::ZStream#reset>))
    を呼び出した直後にのみ有効です。詳細は zlib.h を参照して下さい。

	en| Sets the preset dictionary and returns ((|string|)).
	en| This method is available just only after
	en| ((<Zlib::Deflate.new>)) or ((<Zlib::ZStream#reset>)) method
	en| was called. See zlib.h for details.


== Zlib::Inflate

入力データを展開するストリームのクラス。((<Zlib::Deflate>)) と違い、
このクラスのインスタンスを複製 (clone, dup) することはできません。

	en| The class for decompressing compressed data.
	en| Unlike ((<Zlib::Deflate>)), an instance of this class is not able
	en| to duplicate (clone, dup) itself.

=== スーパークラス:
	en| === SuperClass:

* ((<Zlib::ZStream>))

=== クラスメソッド:
	en| === Class Methods:

--- Zlib::Inflate.inflate(string)

    ((|string|)) を展開します。展開に辞書が必要な場合には
    ((<Zlib::NeedDict>)) 例外が発生します。

	en| Decompresses ((|string|)). Raises a ((<Zlib::NeedDict>))
	en| exception if a preset dictionary is needed for decompression.

    ちなみに、このメソッドは以下のコードとほぼ同じです:

	en| This method is almost equivalent to the following code:

      def inflate(string)
        zstream = Zlib::Inflate.new
        buf = zstream.inflate(string)
        zstream.finish
        zstream.close
        buf
      end

--- Zlib::Inflate.new([windowBits])

    展開ストリームを作成します。引数の詳細は zlib.h を参照して下さい。
    nil の場合はデフォルトの値を使用します。

	en| Creates a new inflate stream for decompression.
	en| See zlib.h for details of the argument.
	en| If ((|windowBits|)) is nil, the default value is used.

=== メソッド:
	en| === Methods:

--- Zlib::Inflate#inflate(string)

    ((|string|)) を展開ストリームに入力します。処理後、ストリームからの
    出力を返します。このメソッドを呼ぶと出力バッファ及び入力バッファは
    空になります。((|string|)) が nil の場合はストリームへの入力を
    終了します。(((<Zlib::ZStream#finish>)) と同じ)。

	en| Inputs ((|string|)) into the inflate stream and returns
	en| the output from the stream. Calling this method,
	en| both input and output buffer of the stream are flushed.
	en| If ((|string|)) is nil, this method finishes the stream,
	en| just like ((<Zlib::ZStream#finish>)).

    展開に辞書が必要な場合には ((<Zlib::NeedDict>)) 例外が発生します。
    ((<Zlib::Inflate#set_dictionary>)) メソッドで辞書をセットした
    後で、空文字列と共にこのメソッドを再度呼び出して下さい。

	en| Raises a ((<Zlib::NeedDict>)) exception if a preset
	en| dictionary is needed to decompress. Set the dictionary
	en| by ((<Zlib::Inflate#set_dictionary>)) and then call
	en| this method again with an empty string.

--- Zlib::Inflate#<< string

    ((<Zlib::Inflate#inflate>)) と同じように ((|string|)) を
    展開ストリームに入力しますが、Zlib::Inflate オブジェクト
    そのものを返します。展開ストリームからの出力は、
    出力バッファに保存されます。

	en| Inputs ((|string|)) into the inflate stream just like
	en| ((<Zlib::Inflate#inflate>)), but returns Zlib::Inflate object
	en| itself. The output from the stream is preserved in output
	en| buffer.

--- Zlib::Inflate#finish

    展開ストリームを終了します。
    ストリーム内に残っていたデータ (つまり圧縮データの後についていた
    ゴミデータ) を返します。
    ((<Zlib::ZStream#finished?>)) が真でない時に finish を呼ぶと
    例外が発生します。

	en| Finishes the inflate stream and returns the garbage
	en| following the compressed data. Raises an exception
	en| if the stream is not finished
	en| (i.e. ((<Zlib::ZStream#finished?>)) doesn't returns true).

    展開ストリームは圧縮データ内に終了コードを発見した時点で
    自ら終了するため、明示的に finish を呼ぶ必要は必ずしも
    ありませんが、このメソッドは圧縮データが正しく終了しているかを
    確認するのに便利です。

	en| The inflate stream finishes itself as soon as it meets
	en| the end code of the compressed data, you need not to call
	en| this method explicitly. However, this method is useful
	en| for checking whether the data is correctly ended or not.

--- Zlib::Inflate#set_dictionary(string)

    展開に用いる辞書を指定します。((|string|)) を返します。
    このメソッドは ((<Zlib::NeedDict>)) 例外が発生した直後のみ
    有効です。詳細は zlib.h を参照して下さい。

	en| Sets the preset dictionary and returns ((|string|))
	en| This method is available just only after a ((<Zlib::NeedDict>))
	en| exception was raised. See zlib.h for details.

--- Zlib::Inflate#sync(string)

    ((|string|)) を入力バッファの末尾に追加し、次の full flush
    point まで読み飛ばします。入力バッファ内に full flush point
    が存在しない場合は、入力バッファを空にし false を返します。
    入力バッファ内に full flush point が見つかった場合は
    true を返し、残りのデータは入力バッファ内に保持されます。

	en| Inputs ((|string|)) into the end of input buffer and
	en| skips data until a full flush point can be found.
	en| If the point is found in the buffer, this method flushes
	en| the buffer and returns false. Otherwise it returns true
	en| and the following data of full flush point is preserved
	en| in the buffer.

--- Zlib::Inflate#sync_point?

    What is this?


== Zlib::GzipFile

gzip 形式の圧縮ファイルを扱う抽象クラス。
具体的な読み込み/書き込み操作は、それぞれサブクラスの
((<Zlib::GzipReader>)), ((<Zlib::GzipWriter>)) で定義されています。

	en| The abstruct class for handling a gzip formatted compressed file.
	en| The operations are defined in the subclasses,
	en| ((<Zlib::GzipReader>)) for reading, and ((<Zlib::GzipWriter>))
	en| for writing.

IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを
持つオブジェクト) と関連付けて使用します。

	en| GzipReader should be used with associating an instance of IO class
	en| (or an object which has the same methods as IO has).

=== スーパークラス:
	en| === SuperClass:

* Object

=== クラスメソッド:
	en| === Class Methods:

--- Zlib::GzipFile.new(args...)

    ((<Zlib::GzipReader.new>)) 及び ((<Zlib::GzipWriter.new>)) を参照。

	en| See ((<Zlib::GzipReader.new>)) and ((<Zlib::GzipWriter.new>)).

--- Zlib::GzipFile.wrap(args...) {|gz| ... }

    ((<Zlib::GzipReader.wrap>)) 及び ((<Zlib::GzipWriter.wrap>)) を参照。

	en| See ((<Zlib::GzipReader.wrap>)) and ((<Zlib::GzipWriter.wrap>)).

--- Zlib::GzipFile.open(args...) {|gz| ... }

    ((<Zlib::GzipReader.open>)) 及び ((<Zlib::GzipWriter.open>)) を参照。

	en| See ((<Zlib::GzipReader.open>)) and ((<Zlib::GzipWriter.open>)).

=== メソッド:
	en| === Methods:

--- Zlib::GzipFile#closed?
--- Zlib::GzipFile#to_io

    IO クラスの同名メソッドと同じ。

	en| Same as IO.

--- Zlib::GzipFile#close

    GzipFile オブジェクトをクローズします。このメソッドは
    関連付けられている IO オブジェクトの close メソッドを呼び出します。
    関連付けられている IO オブジェクトを返します。

	en| Closes the GzipFile object. This method calls close method
	en| of the associated IO object. Returns the associated IO object.

--- Zlib::GzipFile#finish

    GzipFile オブジェクトをクローズします。((<Zlib::GzipFile#close>))と違い、
    このメソッドは関連付けられている IO オブジェクトの close メソッドを
    呼び出しません。関連付けられている IO オブジェクトを返します。

	en| Closes the GzipFile object. Unlike ((<Zlib::GzipFile#close>)),
	en| this method ((*never*)) calls close method of the associated IO
	en| object. Returns the associated IO object.

--- Zlib::GzipFile#crc

    圧縮されていないデータの CRC 値を返します。

	en| Returns CRC value of the uncompressed data.

--- Zlib::GzipFile#level

    圧縮レベルを返します。

	en| Returns compression level.

--- Zlib::GzipFile#mtime

    gzip ファイルのヘッダーに記録されている最終更新時間を返します。

	en| Returns last modification time recorded in the gzip
	en| file header.

--- Zlib::GzipFile#os_code

    gzip ファイルのヘッダーに記録されている OS コード番号を返します。

	en| Returns OS code number recorded in the gzip file header.

--- Zlib::GzipFile#orig_name

    gzip ファイルのヘッダーに記録されている元ファイル名を返します。
    ファイル名が記録されていない場合は nil を返します。

	en| Returns original filename recorded in the gzip file header,
	en| or nil if original filename is not present.

--- Zlib::GzipFile#comment

    gzip ファイルのヘッダーに記録されているコメントを返します。
    コメントが存在しない場合は nil を返します。

	en| Returns comments recorded in the gzip file header, or
	en| nil if the comments is not present.

--- Zlib::GzipFile#sync
--- Zlib::GzipFile#sync= flag

    IO クラスと同じ。((|flag|)) が真の時、関連付けられている
    IO オブジェクトが flush メソッドを持っていなければなりません。
    また、true にすると圧縮率が著しく低下します。

	en| Same as IO. If ((|flag|)) is true, the associated IO object
	en| must respond to flush method. While `sync' mode is true,
	en| the compression ratio decreases sharply.


== Zlib::GzipFile::Error

gzip ファイルを処理している間にエラーが生じた時に発生する全ての例外の
スーパークラス。

	en| The superclass for all exceptions raised during processing a gzip
	en| file.

次の例外が Zlib::GzipFile::Error のサブクラスとして定義されています。

	en| The following exceptions are defined as subclasses of
	en| Zlib::GzipFile::Error.

: Zlib::GzipFile::NoFooter

    gzip ファイルにフッターが無い時に発生します。

	en| Raised when gzip file footer has not found.

: Zlib::GzipFile::CRCError

    フッターに記録されている CRC 値と実際に展開したデータの CRC 値が
    異なる時に発生します。

	en| Raised when the CRC checksum recorded in gzip file footer
	en| is not equivalent to CRC checksum of the actually
	en| uncompressed data.

: Zlib::GzipFile::LengthError

    フッターに記録されているデータ長と実際に展開したデータの
    長さが異なる時に発生します。

	en| Raised when the data length recorded in gzip file footer
	en| is not equivalent to length of the actually uncompressed data.

=== スーパークラス:
	en| === SuperClass:

* ((<Zlib::Error>))


== Zlib::GzipReader

gzip 形式の圧縮ファイルを読み込むラッパークラス。
IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを
持つオブジェクト) と関連付けて使用します。

	en| The class for reading a gzipped file. GzipReader should be used
	en| with associating an instance of IO class (or an object which has
	en| the same methods as IO has).

    Zlib::GzipReader.open('hoge.gz') {|gz|
      print gz.read
    }

    f = File.open('hoge.gz')
    gz = Zlib::GzipReader.new(f)
    print gz.read
    gz.close

=== スーパークラス:
	en| === SuperClass:

* ((<Zlib::GzipFile>))

=== インクルードしているモジュール:
	en| === Included Modules:

* Enumerable

=== クラスメソッド:
	en| === Class Methods:

--- Zlib::GzipReader.new(io)

    ((|io|)) と関連付けられた GzipReader オブジェクトを作成します。
    GzipReader オブジェクトは ((|io|)) からデータを逐次リードして
    解析/展開を行います。((|io|)) には少なくとも、IO#read と
    同じ動作をする read メソッドが定義されている必要があります。

	en| Creates a GzipReader object associated with ((|io|)).
	en| The GzipReader object reads gzipped data from ((|io|)),
	en| and parses/decompresses them. At least, ((|io|)) must have
	en| read method that behaves same as read method in IO class.

    ヘッダーの解析に失敗した場合 ((<Zlib::GzipFile::Error>)) 例外が
    発生します。

	en| If the gzip file header is incorrect, raises an
	en| ((<Zlib::GzipFile::Error>)) exception.

--- Zlib::GzipReader.wrap(io) {|gz| ... }

    ((|io|)) と関連付けられた GzipReader オブジェクトを作成し、
    それを引数としてブロックを実行します。
    ブロックの実行が終了すると、GzipReader オブジェクトは自動的に
    クローズされます。関連付けられている IO オブジェクトまで
    クローズしたくない時は、ブロック中で ((<Zlib::GzipFile#finish>))
    メソッドを呼び出して下さい。

	en| Creates a GzipReader object associated with ((|io|)), and
	en| executes the block with the newly created GzipReader object,
	en| just like File::open. The GzipReader object will be closed
	en| automatically after executing the block. If you want to keep
	en| the associated IO object opening, you may call
	en| ((<Zlib::GzipFile#finish>)) method in the block.

--- Zlib::GzipReader.open(filename)
--- Zlib::GzipReader.open(filename) {|gz| ... }

    ((|filename|)) で指定されるファイルを gzip ファイルとして
    オープンします。GzipReader オブジェクトを返します。
    その他詳細は ((<Zlib::GzipReader.new>)) や ((<Zlib::GzipReader.wrap>)) と
    同じです。

	en| Opens a file specified by ((|filename|)) as a gzipped file,
	en| and returns a GzipReader object associated with that file.
	en| Further details of this method are same as
	en| ((<Zlib::GzipReader.new>)) and ((<ZLib::GzipReader.wrap>)).

=== メソッド:

--- Zlib::GzipReader#eof
--- Zlib::GzipReader#eof?

    圧縮データの終端に達した場合真を返します。
    フッターが読み込まれていなくても真を返すことに注意して下さい。

	en| Returns true if the object reaches the end of compressed data.
	en| Note that eof? does ((*not*)) return true when reaches the
	en| end of ((*file*)).

--- Zlib::GzipReader#pos
--- Zlib::GzipReader#tell

    現在までに展開したデータの長さの合計を返します。
    ファイルポインタの位置ではないことに注意して下さい。

	en| Returns the total bytes of data decompressed until now.
	en| Not that it does ((*not*)) the position of file pointer.

--- Zlib::GzipReader#each([rs])
--- Zlib::GzipReader#each_line([rs])
--- Zlib::GzipReader#each_byte([rs])
--- Zlib::GzipReader#gets([rs])
--- Zlib::GzipReader#getc
--- Zlib::GzipReader#lineno
--- Zlib::GzipReader#lineno=
--- Zlib::GzipReader#read([length])
--- Zlib::GzipReader#readchar
--- Zlib::GzipReader#readline([rs])
--- Zlib::GzipReader#readlines([rs])
--- Zlib::GzipReader#ungetc(char)

    IO クラスの同名メソッドと同じですが、gzip ファイル中に
    エラーがあった場合 ((<Zlib::Error>)) 例外や
    ((<Zlib::GzipFile::Error>)) 例外が発生します。

	en| Same as IO, but raises ((<Zlib::Error>)) or
	en| ((<Zlib::GzipFile::Error>)) exception if an error was found
	en| in the gzip file.

    gzip ファイルのフッターの処理に注意して下さい。
    gzip ファイルのフッターには圧縮前データのチェックサムが
    記録されています。GzipReader オブジェクトは、次の時に展開した
    データとフッターの照合を行い、エラーがあった場合は
    ((<Zlib::GzipFile::NoFooter>)), ((<Zlib::GzipFile::CRCError>)),
    ((<Zlib::GzipFile::LengthError>)) 例外を発生させます。

	en| Be careful of the footer of gzip file. A gzip file has
	en| the checksum of pre-compressed data in its footer.
	en| GzipReader checks all uncompressed data against that checksum
	en| at the following cases, and if failed, raises
	en| ((<Zlib::GzipFile::NoFooter>)), ((<Zlib::GzipFile::CRCError>)),
	en| or ((<Zlib::GzipFile::LengthError>)) exception.

    * EOF (圧縮データの最後) を越えて読み込み要求を受けた時。
      すなわち ((<Zlib::GzipReader#read>)),
      ((<Zlib::GzipReader#gets>)) メソッド等が nil を返す時。

	en| * When an reading request is received beyond the end of file
	en|   (the end of compressed data).
	en|   That is, when ((<Zlib::GzipReader#read>)),
	en|   ((<Zlib::GzipReader#gets>)), or some other methods for reading
	en|   returns nil.

    * EOF まで読み込んだ後、((<Zlib::GzipFile#close>)) メソッドが
      呼び出された時。

	en| * When ((<Zlib::GzipFile#close>)) method is called after
	en|   the object reaches the end of file.

    * EOF まで読み込んだ後、((<Zlib::GzipReader#unused>)) メソッドが
      呼び出された時。

	en| * When ((<Zlib::GzipReader#unused>)) method is called after
	en|   the object reaches the end of file.

--- Zlib::GzipReader#rewind

    ファイルポインタを ((<Zlib::GzipReader.new>)) を呼び出した直後の
    時点に戻します。関連付けられている IO オブジェクトに
    seek メソッドが定義されている必要があります。

	en| Resets the position of the file pointer to the point
	en| created the GzipReader object.
	en| The associated IO object need to respond to seek method.

--- Zlib::GzipReader#unused

    gzip フォーマットの解析のために読み込んだ余剰のデータを返します。
    gzip ファイルが最後まで解析されていない場合は nil を返します。

	en| Returns the rest of the data which had read for parsing gzip
	en| format, or nil if the whole gzip file is not parsed yet.


== Zlib::GzipWriter

gzip 形式の圧縮ファイルを書き出すラッパークラス。
IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを
持つオブジェクト) と関連付けて使用します。

	en| The class for writing a gzipped file. GzipWriter should be used
	en| with associate with an instance of IO class (or an object which
	en| has the same methods as IO has).

    Zlib::GzipWriter.open('hoge.gz') {|gz|
      gz.write 'jugemu jugemu gokou no surikire...'
    }

    f = File.open('hoge.gz', 'w')
    gz = Zlib::GzipWriter.new(f)
    gz.write 'jugemu jugemu gokou no surikire...'
    gz.close

なお、Ruby の finalizer の制約のため、GzipWriter オブジェクトは必ず
((<Zlib::GzipWriter#close>)) 等を用いてクローズしてください。
そうしなければフッターを書き出すことができず、壊れた gzip ファイルを
生成してしまう可能性があります。

	en| NOTE: Due to the limitation in finalizer of Ruby, you must close
	en| explicitly GzipWriter object by ((<Zlib::GzipWriter#close>)) etc.
	en| Otherwise, GzipWriter should be not able to write gzip footer and
	en| generate broken gzip file.

=== スーパークラス:
	en| === SuperClass:

* ((<Zlib::GzipFile>))

=== クラスメソッド:
	en| === Class Methods:

--- Zlib::GzipWriter.new(io[, level[, strategy]])

    ((|io|)) と関連付けられた GzipWriter オブジェクトを作成します。
    ((|level|)), ((|strategy|)) は ((<Zlib::Deflate.new>)) と同じです。
    GzipWriter オブジェクトは ((|io|)) に gzip 形式のデータを
    逐次ライトします。((|io|)) には少なくとも、IO#write と
    同じ動作をする write メソッドが定義されている必要があります。

	en| Creates a GzipWriter object associated with ((|io|)).
	en| ((|level|)) and ((|strategy|)) should be same as the
	en| arguments of ((<Zlib::Deflate.new>)). The GzipWriter object
	en| writes gzipped data to ((|io|)). At least, ((|io|)) must
	en| respond to write method that behaves same as write method
	en| in IO class.

--- Zlib::GzipWriter.wrap(io[, level[, strategy]]) {|gz| ... }

    ((|io|)) と関連付けられた GzipWriter オブジェクトを作成し、
    それを引数としてブロックを実行します。
    ブロックの実行が終了すると、GzipWriter オブジェクトは自動的に
    クローズされます。関連付けられている IO オブジェクトまで
    クローズしたくない時は、ブロック中で ((<Zlib::GzipFile#finish>))
    メソッドを呼び出して下さい。

	en| Creates a GzipWriter object associated with ((|io|)), and
	en| executes the block with the newly created GzipWriter object,
	en| just like File::open. The GzipWriter object will be closed
	en| automatically after executing the block. If you want to keep
	en| the associated IO object opening, you may call
	en| ((<Zlib::GzipFile#finish>)) method in the block.

--- Zlib::GzipWriter.open(filename[, level[, strategy]])
--- Zlib::GzipWriter.open(filename[, level[, strategy]]) {|gz| ... }

    ((|filename|)) で指定されるファイルを gzip 圧縮データの
    書き出し用にオープンします。GzipWriter オブジェクトを返します。
    その他詳細は ((<Zlib::GzipWriter.new>)) や ((<Zlib::GzipWriter.wrap>)) と
    同じです。

	en| Opens a file specified by ((|filename|)) for writing
	en| gzip compressed data, and returns a GzipWriter object
	en| associated with that file. Further details of this method
	en| are same as ((<Zlib::GzipWriter.new>)) and
	en| ((<Zlib::GzipWriter#wrap>)).


=== メソッド:
	en| === Methods:

--- Zlib::GzipWriter#close
--- Zlib::GzipWriter#finish

    フッターを書き出し、GzipWriter オブジェクトをクローズします。close と
    finish の違いは ((<Zlib::GzipFile#close>)), ((<Zlib::GzipFile#finish>)) を
    参照して下さい。

	en| Closes the GzipFile object. This method calls close method
	en| of the associated IO object. Returns the associated IO object.
	en| See ((<Zlib::GzipFile#close>)) and ((<Zlib::GzipFile#finish>))
	en| for the difference between close and finish.

    ((*注意: Ruby の finalizer の制約のため、GzipWriter オブジェクトは
    必ずクローズしてください。そうしなければフッターを書き出すことが
    できず、壊れた gzip ファイルを生成してしまう可能性があります。*))

	en| ((*NOTE: Due to the limitation in finalizer of Ruby, you must
	en| close GzipWriter object explicitly. Otherwise, GzipWriter
	en| should be not able to write gzip footer and generate broken
	en| gzip file.*))

--- Zlib::GzipWriter#pos
--- Zlib::GzipWriter#tell

    現在までに圧縮したデータの長さの合計を返します。
    ファイルポインタの位置ではないことに注意して下さい。

	en| Returns the total bytes of data compressed until now.
	en| Note that it does ((*not*)) the position of file pointer.

--- Zlib::GzipWriter#<< str
--- Zlib::GzipWriter#putc(ch)
--- Zlib::GzipWriter#puts(obj...)
--- Zlib::GzipWriter#print(arg...)
--- Zlib::GzipWriter#printf(format, arg...)
--- Zlib::GzipWriter#write(str)

    IO クラスの同名メソッドと同じ。

	en| Same as IO.

--- Zlib::GzipWriter#flush([flush])

    まだ書き出されていないデータをフラッシュします。
    ((|flush|)) は ((<Zlib::Deflate#deflate>)) と同じです。
    省略時は ((<Zlib::SYNC_FLUSH>)) が使用されます。
    ((|flush|)) に ((<Zlib::NO_FLUSH>)) を指定することは無意味です。

	en| Flushes all the internal buffers of the GzipWriter object.
	en| The meaning of ((|flush|)) is same as one of the argument of
	en| ((<Zlib::Deflate#deflate>)).
	en| ((<Zlib::SYNC_FLUSH>)) is used if ((|flush|)) is omitted.
	en| It is no use giving ((|flush|)) ((<Zlib::NO_FLUSH>)).

--- Zlib::GzipWriter#mtime= time

    gzip ファイルのヘッダーに記録する最終更新時間を指定します。
    ((<Zlib::GzipWriter#write>)) 等の書き込み系メソッドを
    呼んだ後で指定しようとすると ((<Zlib::GzipFile::Error>)) 例外が
    発生します。

	en| Sets last modification time to be stored in the gzip file
	en| header. ((<Zlib::GzipFile::Error>)) exception will be raised
	en| if this method is called after writing method (like
	en| ((<Zlib::GzipWriter#write>))) was called.

--- Zlib::GzipWriter#orig_name= filename

    gzip ファイルのヘッダーに記録する元ファイル名を指定します。
    ((<Zlib::GzipWriter#write>)) 等の書き込み系メソッドを
    呼んだ後で指定しようとすると ((<Zlib::GzipFile::Error>)) 例外が
    発生します。

	en| Sets original filename to be stored in the gzip file header.
	en| ((<Zlib::GzipFile::Error>)) exception will be raised
	en| if this method is called after writing method (like
	en| ((<Zlib::GzipWriter#write>))) was called.

--- Zlib::GzipWriter#comment= string

    gzip ファイルのヘッダーに記録するコメントを指定します。
    ((<Zlib::GzipWriter#write>)) 等の書き込み系メソッドを
    呼んだ後で指定しようとすると ((<Zlib::GzipFile::Error>)) 例外が
    発生します。

	en| Sets comments to be stored in the gzip file header.
	en| ((<Zlib::GzipFile::Error>)) exception will be raised
	en| if this method is called after writing method (like
	en| ((<Zlib::GzipWriter#write>))) was called.


== 0.5 から 0.6 への変更点
	en| == Changes from 0.5 to 0.6

* 新しいメソッド:

	en| * New methods:

  * ((<Zlib::GzipFile.wrap>))
  * ((<Zlib::GzipFile#finish>))

* 新しい定数:

	en| * New constants:

  * ((<Zlib::ZLIB_VERSION>))
  * ((<Zlib::OS_VMCMS>))
  * ((<Zlib::OS_ZSYSTEM>))
  * ((<Zlib::OS_CPM>))
  * ((<Zlib::OS_QDOS>))
  * ((<Zlib::OS_RISCOS>))
  * ((<Zlib::OS_UNKNOWN>))

* 仕様が変更されたメソッド:

	en| * Changed methods:

  * ((<Zlib::GzipFile.new>))にブロックを渡せなくなりました。代わりに
    ((<Zlib::GzipFile.wrap>))を使って下さい。

	en| * ((<Zlib::GzipFile.new>)) now takes no block. Use
	en|   ((<Zlib::GzipFile.wrap>)) instead.

  * ((<Zlib::GzipFile#close>))の引数がなくなりました。代わりに
    ((<Zlib::GzipFile#finish>))を使って下さい。

	en| * ((<Zlib::GzipFile#close>)) now takes no argument. Use
	en|   ((<Zlib::GzipFile#finish>)) instead.

* 名前が変更されたメソッド:

	en| * Renamed methods:

  * Zlib.versionは((<Zlib.zlib_version>))にリネームされました。

	en| * Zlib.version is renamed to ((<Zlib.zlib_version>)).

* 仕様が変更された定数:

	en| * Changed constants:

  * ((<Zlib::VERSION>))はRuby/zlibのバージョンを表す文字列になりました。
    zlib.h のバージョンは((<Zlib::ZLIB_VERSION>))になります。

	en| * ((<Zlib::VERSION>)) indicates the version of Ruby/zlib.
	en|   The zlib.h version is now in ((<Zlib::ZLIB_VERSION>)).

* 後方互換性:

	en| * Backward compatibility:

  * 0.5 との互換性のために以前のメソッドや引数は残してあります。

	en| * For backward compatibility for 0.5, the obsoleted methods and
	en|   arguments are still available.

  * 0.4 以前との互換性のために残していたクラス・定数・メソッドは
    削除されました。

	en| * Obsoleted classes, methods, and constants for backward
	en|   compatibility for 0.4 or earlier are removed.

== 0.4 から 0.5 への変更点
	en| == Changes from 0.4 to 0.5

全体的に書き換えてます。これで全部…だといいなぁ(汗::

	en| Almost all the code are rewritten.
	en| I hope all changes are enumerated below :-)

* クラス名、メソッド名の変更。全てのクラスと定数は ((<Zlib>)) 以下に
  移しました。0.4 との互換性のために以前のものも残してあります。

	en| * The names of almost classes and some methods are changed.
	en|   All classes and constants are now defined under module
	en|   ((<Zlib>)). The obsoleted names are also available for backward
	en|   compatibility.

  * クラス
	en| * Classes

    * Deflate -> ((<Zlib::Deflate>))
    * Inflate -> ((<Zlib::Inflate>))
    * Zlib::Gzip -> ((<Zlib::GzipFile>))
    * GzipReader -> ((<Zlib::GzipReader>))
    * GzipWriter -> ((<Zlib::GzipWriter>))
    * Zlib::Gzip::Error -> ((<Zlib::GzipFile::Error>))
    * Zlib::GzipReader::NoFooter -> ((<Zlib::GzipFile::NoFooter>))
    * Zlib::GzipReader::CRCError -> ((<Zlib::GzipFile::CRCError>))
    * Zlib::GzipReader::LengthError -> ((<Zlib::GzipFile::LengthError>))

  * 定数
	en| * Constants

    * Zlib::ZStream::BINARY -> ((<Zlib::BINARY>))
    * Zlib::ZStream::ASCII -> ((<Zlib::ASCII>))
    * Zlib::ZStream::UNKNOWN -> ((<Zlib::UNKNOWN>))
    * Zlib::Deflate::NO_COMPRESSION -> ((<Zlib::NO_COMPRESSION>))
    * Zlib::Deflate::BEST_SPEED -> ((<Zlib::BEST_SPEED>))
    * Zlib::Deflate::BEST_COMPRESSION -> ((<Zlib::BEST_COMPRESSION>))
    * Zlib::Deflate::DEFAULT_COMPRESSION -> ((<Zlib::DEFAULT_COMPRESSION>))
    * Zlib::Deflate::FILTERED -> ((<Zlib::FILTERED>))
    * Zlib::Deflate::HUFFMAN_ONLY -> ((<Zlib::HUFFMAN_ONLY>))
    * Zlib::Deflate::DEFAULT_STRATEGY -> ((<Zlib::DEFAULT_STRATEGY>))
    * Zlib::Deflate::MAX_WBITS -> ((<Zlib::MAX_WBITS>))
    * Zlib::Deflate::DEF_MEM_LEVEL -> ((<Zlib::DEF_MEM_LEVEL>))
    * Zlib::Deflate::MAX_MEM_LEVEL -> ((<Zlib::MAX_MEM_LEVEL>))
    * Zlib::Deflate::NO_FLUSH -> ((<Zlib::NO_FLUSH>))
    * Zlib::Deflate::SYNC_FLUSH -> ((<Zlib::SYNC_FLUSH>))
    * Zlib::Deflate::FULL_FLUSH -> ((<Zlib::FULL_FLUSH>))
    * Zlib::Inflate::MAX_WBITS -> ((<Zlib::MAX_WBITS>))
    * Zlib::GzipReader::OS_* -> ((<Zlib::OS_*|Zlib::OS_CODE>))

  * メソッド
	en| * Methods

    * Zlib::ZStream#flush_out -> ((<Zlib::ZStream#flush_next_out>))

* 入力側 (next_in) にもバッファを設ける。

	en| * Made buffer for input (next_in).

* ((<Zlib::GzipReader#unused>)) はクローズ後は nil を返す。

	en| * ((<Zlib::GzipReader#unused>)) returns nil after closing.

* ((<Zlib::GzipWriter#close>)) の義務化。finalizer での segv を回避。
  ((<[ruby-dev:11915]|URL:http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-dev/11915>))

	en| * Now you are up to call ((<Zlib::GzipWriter#close>)) explicitly
	en| to avoid segv in finalizer.
	en| ((<[ruby-dev:11915]|URL:http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-dev/11915>))

* new と initialize を分けた。

	en| * divided initialize from new.

* deflateInit2, inflateInit2 に渡す引数の sanity check をしないようにした。

	en| * remove sanity checks for arguments for deflateInit2 and
	en|   inflateInit2.

* ((<Zlib::GzipWriter#puts>)) の挙動は Ruby-1.7 に合わせることにした。

	en| * adapted the behavior of ((<Zlib::GzipWriter#puts>)) to Ruby-1.7.

* 全関数を static に。

	en| * Made all functions static.


=end
