=begin
#
# zlib.rd.src
#
#   Copyright (C) UENO Katsuhiro 2000-2002
#
#   $Id: zlib.rd.src,v 1.14 2002/03/13 19:13:14 katsu Exp $
#


= Ruby/zlib version 0.5.0

ja| Ruby/zlib は zlib を Ruby から使うための拡張ライブラリです。
ja| gzip ファイルの読み書きもサポートします。
#|
en|    Ruby/zlib is an extension library to use zlib from Ruby.
en|    Ruby/zlib also provides the features for accessing gzipped files.

ja| Ruby/zlib は Ruby と同じ条件で変更/配布することができます。
ja| Ruby/zlib の最新版は ((<URL:http://www.blue.sky.or.jp/>)) から
ja| 入手できます。
#|
en|    You can modify or redistribute Ruby/zlib in the same manner of Ruby
en|    interpreter. The latest version of Ruby/zlib would be found at
en|    ((<URL:http://www.blue.sky.or.jp/>)).

ja| Ruby/zlib に対するご意見、バグレポート等は ruby-list ML, ruby-dev ML,
ja| ruby-ext ML, ruby-talk ML, 又は ((<URL:mailto:katsu@blue.sky.or.jp>))
ja| までお願いします。
#|
en|    Any comments and suggestions are always welcome. Please send them to
en|    ruby-list ML, ruby-ext ML, ruby-talk ML, or the author's mail address
en|    ((<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 kidding
en|    or unnatural ones) in this document, please let me know for my study.

__||  * ((<Zlib>))
        * ((<Zlib::Error>))
        * ((<Zlib::ZStream>))
        * ((<Zlib::Deflate>))
        * ((<Zlib::Inflate>))
        * ((<Zlib::GzipFile>))
          * ((<Zlib::GzipFile::Error>))
        * ((<Zlib::GzipWriter>))
        * ((<Zlib::GzipReader>))
ja||  * ((<0.4.0 からの変更点>))
en||  * ((<Changes from 0.4.0>))



== Zlib

ja| zlib ライブラリに含まれている雑多な機能を提供するモジュール。
ja| 各モジュール関数の詳細は 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.

=== モジュール関数:

--- Zlib.version
        ja| zlib ライブラリのバージョンを表す文字列を返します。
        #|
        en|    Returns the string which represents the version of zlib
        en|    library.

--- Zlib.adlar32([string[, adlar]])
        ja| ((|string|)) の Adler-32 チェックサムを計算し、((|adler|)) を
        ja| 更新した値を返します。((|string|)) が省略された場合は
        ja| Adler-32 チェックサムの初期値を返します。((|adler|)) が
        ja| 省略された場合は ((|adler|)) に初期値が与えらたものとして
        ja| 計算します。
        #|
        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]])
        ja| ((|string|)) の CRC チェックサムを計算し、((|crc|)) を
        ja| 更新した値を返します。((|string|)) が省略された場合は
        ja| CRC チェックサムの初期値を返します。((|crc|)) が
        ja| 省略された場合は ((|crc|)) に初期値が与えらたものとして
        ja| 計算します。
        #|
        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
        ja| CRC チェックサムの計算に用いるテーブルを配列で返します。
        #|
        en|    Returns the table for calculating CRC checksum as an array.

=== 定数:

--- Zlib::VERSION
        ja| zlib.h のバージョンを表す文字列。
        #|
        en|    The string which represents the version of zlib.h.

--- Zlib::BINARY
--- Zlib::ASCII
--- Zlib::UNKNOWN
        ja| ((<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
        ja| ((<Zlib::Deflate.new>)) や ((<Zlib::Deflate#deflate>)) 等に渡す、
        ja| 圧縮レベルを表す整数。
        #|
        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
        ja| ((<Zlib::Deflate.new>)) や ((<Zlib::Deflate#params>)) に渡す、
        ja| 圧縮方法を表す整数。
        #|
        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
        ja| ((<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
        ja| ((<Zlib::Deflate.new>)) や ((<Zlib::Inflate.new>)) での
        ja| ((|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
        ja| ((<Zlib::Deflate#deflate>)) 等に渡す、ストリームの出力を
        ja| 制御するための整数。
        #|
        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_ATARI
--- Zlib::OS_OS
--- Zlib::OS_MACOS
--- Zlib::OS_TOPS
--- Zlib::OS_WIN
        ja| ((<Zlib::GzipFile#os_code>)) メソッドの返す値。
        #|
        en|    The return values of ((<Zlib::GzipFile#os_code>)) method.



== Zlib::Error

ja| Ruby/zlib の発行する全ての例外のスーパークラス。
ja|
ja| 以下の例外が Zlib::Error のサブクラスとして定義されています。
ja| それぞれ zlib ライブラリ関数の返すエラーと対応しています。
#|
en|    The superclass for all excpetions raised by Ruby/zlib.
en|
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

=== スーパークラス:

* StandardError



== Zlib::ZStream

ja| 圧縮データを扱うストリームを表す抽象クラス。
ja| 具体的な圧縮/展開の操作は、それぞれサブクラスの ((<Zlib::Deflate>)),
ja| ((<Zlib::Inflate>)) で定義されています。
#|
en|    The abstruct class for the stream which handles the compressed data.
en|    The operations are defined in the subclasses, ((<Zlib::Deflate>))
en|    for compression, and ((<Zlib::Inflate>)) for decpmpression.

ja| Zlib::ZStream オブジェクトは、ストリーム (struct zstream) の
ja| 入力側 (next_in) と出力側 (next_out) にそれぞれ可変長の
ja| バッファを持ちます。以下、入力側のバッファを「入力バッファ」、
ja| 出力側のバッファを「出力バッファ」と呼びます。
#|
en|    An instance of Zlib::ZStream has one stream (struct zstream) and
en|    two variable-length buffers which associated to the input (next_in)
en|    of the stream and the output (next_out) of the stream. In this document,
en|    "input buffer" means the buffer for input, and "output buffer" means
en|    the buffer for output.

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

ja| いくつかのメソッドは、出力バッファ内のデータを取り出し、
ja| String オブジェクトとして返します。
#|
en|    Some paticular instance methods consume the data in output buffer
en|    and return them as a String.

ja| 以上を図示すると次のようになります:
#|
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"

ja| 入力バッファの内容を処理している最中にエラーが発生した場合、
ja| ((<Zlib::Error>)) のサブクラスの例外が発生します。その時、
ja| 入力/出力バッファは共に、エラーが発生した時点の状態をそのまま
ja| 保持します。
#|
en|    If an error is occured 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 occured.

=== スーパークラス:

* Object

=== クラスメソッド:

--- Zlib::ZStream.new
        ja| ((<Zlib::Deflate.new>)) 及び ((<Zlib::Inflate.new>)) を
        ja| 参照。
        #|
        en|    See ((<Zlib::Deflate.new>)) and ((<Zlib::Inflate.new>)).

=== メソッド:

--- Zlib::ZStream#avail_in
        ja| 入力バッファに溜っているデータのバイト数を返します。
        ja| 通常は 0 です。
        #|
        en|    Returns bytes of data in input buffer.
        en|    Normally, returns 0.

--- Zlib::ZStream#avail_out
        ja| 出力バッファの空き用量をバイト数で返します。
        ja| 空きは必要な時に動的に確保されるため、通常は 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
        ja| 出力側のバッファに ((|size|)) バイトの空きを確保します。
        ja| すでに ((|size|)) バイト以上の空きがある場合、バッファは
        ja| 縮められます。空きは必要な時に動的に確保されるため、通常
        ja| このメソッドを使う必要はありません。
        #|
        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
        ja| 入力バッファに残っているデータを強制的に取り出します。
        #|
        en|    Flushes input buffer and returns all data in that buffer.

--- Zlib::ZStream#flush_next_out
        ja| 出力バッファに残っているデータを強制的に取り出します。
        #|
        en|    Flushes output buffer and returns all data in that buffer.

--- Zlib::ZStream#total_in
        ja| ストリームに入力されたデータの総バイト数を返します。
        #|
        en|    Returns the total bytes of the input data to the stream.

--- Zlib::ZStream#total_out
        ja| ストリームの出力したデータの総バイト数を返します。
        #|
        en|    Returns the total bytes of the output data from the stream.

--- Zlib::ZStream#data_type
        ja| ストリームに入力されたデータの形式を推測します。
        ja| 返り値は ((<Zlib::BINARY>)), ((<Zlib::ASCII>)),
        ja| ((<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
        ja| alder-32 チェックサムを返します。
        #|
        en|    Returns the alder-32 checksum.

--- Zlib::ZStream#reset
        ja| ストリームの状態をリセットします。
        ja| 入力/出力バッファ内に残っていたデータは破棄されます。
        #|
        en|    Resets and initializes the stream. All data in both
        en|    input and output buffer are discarded.

--- Zlib::ZStream#finish
        ja| ストリームへの入力を終了し、出力バッファをフラッシュします。
        ja| より具体的な振る舞いは ((<Zlib::Deflate#finish>)),
        ja| ((<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?
        ja| ストリームへの入力が終了している時に真を返します。
        #|
        en|    Returns true if the stream is finished.

--- Zlib::ZStream#close
--- Zlib::ZStream#end
        ja| ストリームを閉じます。
        ja| 以後、このストリームにアクセスすることはできなくなります。
        #|
        en|    Closes the stream. All operations on the closed stream
        en|    will raise an exception.

--- Zlib::ZStream#closed?
--- Zlib::ZStream#ended?
        ja| ストリームが閉じられている時に真を返します。
        #|
        en|    Returns true if the stream closed.



== Zlib::Deflate

ja| 入力データを圧縮するストリームのクラス。
#|
en|    The class for compressing string data.

=== スーパークラス:

* ((<Zlib::ZStream>))

=== クラスメソッド:

--- Zlib::Deflate.deflate(string[, level])
        ja| ((|string|)) を圧縮します。((|level|)) の有効な値は
        ja| ((<Zlib::NO_COMPRESSION>)), ((<Zlib::BEST_SPEED>)),
        ja| ((<Zlib::BEST_COMPRESSION>)), ((<Zlib::DEFAULT_COMPRESSION>))
        ja| 及び 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.

        ja| ちなみに、このメソッドは以下のコードとほぼ同じです:
        #|
        en|    This method is almostly equivalant 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]]]])
        ja| 圧縮ストリームを作成します。各引数の詳細は zlib.h を
        ja| 参照して下さい。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.

=== メソッド:

--- Zlib::Deflate#clone
        ja| 圧縮ストリームを複製します。
        #|
        en|    Duplicates the deflate stream.

--- Zlib::Deflate#deflate(string[, flush])
        ja| ((|string|)) を圧縮ストリームに入力します。処理後、
        ja| ストリームからの出力を返します。このメソッドを呼ぶと
        ja| 出力バッファ及び入力バッファは空になります。
        ja| ((|string|)) が nil の場合はストリームへの入力を
        ja| 終了します。(((<Zlib::ZStream#finish>)) と同じ)。
        ja| ((|flush|)) には ((<Zlib::NO_FLUSH>)), ((<Zlib::SYNC_FLUSH>)),
        ja| ((<Zlib::FULL_FLUSH>)), ((<Zlib::FINISH>)) のいずれかを指定します。
        ja| 詳しくは 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
        ja| ((<Zlib::Deflate#deflate>)) と同じように ((|string|)) を
        ja| 圧縮ストリームに入力しますが、Zlib::Deflate オブジェクト
        ja| そのものを返します。圧縮ストリームからの出力は、
        ja| 出力バッファに保存されます。
        #|
        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])
        ja| (({deflate('', ((|flush|)))})) と同じです。((|flush|)) が
        ja| 省略された時は ((<Zlib::SYNC_FLUSH>)) が使用されます。
        ja| このメソッドはスクリプトの可読性のために提供されています。
        #|
        en|    This method is equivalant 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
        ja| 圧縮ストリームを終了します。(({deflate('', Zlib::FINISH)})) と
        ja| 同じです。
        #|
        en|    Finishes the stream. This method is equivalant to
        en|    (({deflate('', Zlib::FINISH)})).

--- Zlib::Deflate#params(level, strategy)
        ja| 圧縮ストリームの設定を変更します。詳しくは zlib.h を
        ja| 参照して下さい。設定の変更に伴うストリームからの出力は
        ja| 出力バッファに保存されます。
        #|
        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)
        ja| 圧縮に用いる辞書を指定します。((|string|)) を返します。
        ja| このメソッドは ((<Zlib::Deflate.new>)), ((<Zlib::ZStream#reset>))
        ja| を呼び出した直後にのみ有効です。詳細は 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

ja| 入力データを展開するストリームのクラス。((<Zlib::Deflate>)) と違い、
ja| このクラスのインスタンスを複製 (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.

=== スーパークラス:

* ((<Zlib::ZStream>))

=== クラスメソッド:

--- Zlib::Inflate.inflate(string)
        ja| ((|string|)) を展開します。展開に辞書が必要な場合には
        ja| ((<Zlib::NeedDict>)) 例外が発生します。
        #|
        en|    Decompresses ((|string|)). Raises a ((<Zlib::NeedDict>))
        en|    exception if a preset dictionary is needed for decompression.

        ja| ちなみに、このメソッドは以下のコードとほぼ同じです:
        #|
        en|    This method is almostly equivalant 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])
        ja| 展開ストリームを作成します。引数の詳細は zlib.h を参照して下さい。
        ja| 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.

=== メソッド:

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

        ja| 展開に辞書が必要な場合には ((<Zlib::NeedDict>)) 例外が発生します。
        ja| ((<Zlib::Inflate#set_dictionary>)) メソッドで辞書をセットした
        ja| 後で、空文字列と共にこのメソッドを再度呼び出して下さい。
        #|
        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
        ja| ((<Zlib::Inflate#inflate>)) と同じように ((|string|)) を
        ja| 展開ストリームに入力しますが、Zlib::Inflate オブジェクト
        ja| そのものを返します。展開ストリームからの出力は、
        ja| 出力バッファに保存されます。
        #|
        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
        ja| 展開ストリームを終了します。
        ja| ストリーム内に残っていたデータ (つまり圧縮データの後についていた
        ja| ゴミデータ) を返します。
        ja| ((<Zlib::ZStream#finished?>)) が真でない時に finish を呼ぶと
        ja| 例外が発生します。
        #|
        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).

        ja| 展開ストリームは圧縮データ内に終了コードを発見した時点で
        ja| 自ら終了するため、明示的に finish を呼ぶ必要は必ずしも
        ja| ありませんが、このメソッドは圧縮データが正しく終了しているかを
        ja| 確認するのに便利です。
        #|
        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|    thisd method explicitly. However, this method is useful
        en|    for checking whether the data is correctly ended or not.

--- Zlib::Inflate#set_dictionary(string)
        ja| 展開に用いる辞書を指定します。((|string|)) を返します。
        ja| このメソッドは ((<Zlib::NeedDict>)) 例外が発生した直後のみ
        ja| 有効です。詳細は 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)
        ja| ((|string|)) を入力バッファの末尾に追加し、次の full flush
        ja| point まで読み飛ばします。入力バッファ内に full flush point
        ja| が存在しない場合は、入力バッファを空にし false を返します。
        ja| 入力バッファ内に full flush point が見つかった場合は
        ja| 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

ja| gzip 形式の圧縮ファイルを扱う抽象クラス。
ja| 具体的な読み込み/書き込み操作は、それぞれサブクラスの
ja| ((<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.

ja| IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを
ja| 持つオブジェクト) と関連付けて使用します。
#|
en|    GzipReader should be used with associating an instance of IO class
en|    (or an object which has the same methods as IO has).

=== スーパークラス:

* Object

=== クラスメソッド:

--- Zlib::GzipFile.new(io)
        ja| ((<Zlib::GzipReader.new>)) 及び ((<Zlib::GzipWriter.new>)) を
        ja| 参照。
        #|
        en|    See ((<Zlib::GzipReader.new>)) and ((<Zlib::GzipWriter.new>)).

=== メソッド:

--- Zlib::GzipFile#closed?
--- Zlib::GzipFile#to_io
        ja| IO クラスの同名メソッドと同じ。
        #|
        en|    Same as IO.

--- Zlib::GzipFile#close([dont_close_io])
        ja| GzipFile オブジェクトをクローズします。((|dont_close_io|)) が
        ja| 省略されている時や ((|dont_close_io|)) が真でない時、
        ja| 関連付けられている IO オブジェクトの close メソッドを呼び出します。
        ja| 関連付けられている IO オブジェクトを返します。
        #|
        en|    Closes the GzipReader object. If ((|dont_close_io|)) is
        en|    ommited or not true, close method of the associated IO object
        en|    is called. Returns the associated IO object.

--- Zlib::GzipFile#crc
        ja| 圧縮されていないデータの CRC 値を返します。
        #|
        en|    Returns CRC value of the uncompressed data.

--- Zlib::GzipFile#level
        ja| 圧縮レベルを返します。
        #|
        en|    Returns compression level.

--- Zlib::GzipFile#mtime
        ja| gzip ファイルのヘッダーに記録されている最終更新時間を返します。
        #|
        en|    Returns last modification time recorded in the gzip
        en|    file header.

--- Zlib::GzipFile#os_code
        ja| gzip ファイルのヘッダーに記録されている OS コード番号を返します。
        #|
        en|    Returns OS code number recorded in the gzip file header.

--- Zlib::GzipFile#orig_name
        ja| gzip ファイルのヘッダーに記録されている元ファイル名を返します。
        ja| ファイル名が記録されていない場合は nil を返します。
        #|
        en|    Returns original filename recorded in the gzip file header,
        en|    or nil if original filename is not present.

--- Zlib::GzipFile#comment
        ja| gzip ファイルのヘッダーに記録されているコメントを返します。
        ja| コメントが存在しない場合は 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
        ja| IO クラスと同じ。((|flag|)) が真の時、関連付けられている
        ja| IO オブジェクトが flush メソッドを持っていなければなりません。
        ja| また、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

ja| gzip ファイルを処理している間にエラーが生じた時に発生する全ての例外の
ja| スーパークラス。
#|
en|    The superclass for all exceptions raised during processing a gzip
en|    file.
en|
en|    The following exceptions are defined as subclasses of
en|    Zlib::GzipFile::Error.

  : Zlib::GzipFile::NoFooter
        ja| gzip ファイルにフッターが無い時に発生します。
        #|
        en|    Raised when gzip file footer has not found.

  : Zlib::GzipFile::CRCError
        ja| フッターに記録されている CRC 値と実際に展開したデータの
        ja| CRC 値が異なる時に発生します。
        #|
        en|    Raised when the CRC checksum recorded in gzip file footer
        en|    is not equivalant to CRC checksum of the actually
        en|    uncompressed data.

  : Zlib::GzipFile::LengthError
        ja| フッターに記録されているデータ長と実際に展開したデータの
        ja| 長さが異なる時に発生します。
        #|
        en|    Raised when the data length recorded in gzip file footer
        en|    is not equivalant to length of the actually uncompressed data.

=== スーパークラス:

* ((<Zlib::Error>))



== Zlib::GzipReader

ja| gzip 形式の圧縮ファイルを読み込むラッパークラス。
ja| IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを
ja| 持つオブジェクト) と関連付けて使用します。
#|
en|    The class for reading a gzipped file. GzipReader should be used with
en|    associating an instance of IO class (or an object which has the same
en|    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

=== スーパークラス:

* ((<Zlib::GzipFile>))

=== インクルードしているモジュール:

* Enumerable

=== クラスメソッド:

--- Zlib::GzipReader.new(io)
--- Zlib::GzipReader.new(io) {|gz| ... }
        ja| ((|io|)) と関連付けられた GzipReader オブジェクトを作成します。
        ja| GzipReader オブジェクトは ((|io|)) からデータを逐次リードして
        ja| 解析/展開を行います。((|io|)) には少なくとも、IO#read と
        ja| 同じ動作をする 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.

        ja| ヘッダーの解析に失敗した場合 ((<Zlib::GzipFile::Error>)) 例外が
        ja| 発生します。
        #|
        en|    If the gzip file header is incorrect, raises an
        en|    ((<Zlib::GzipFile::Error>)) exception.

        ja| ブロックを指定して呼び出した場合は、File.open と同じように
        ja| GzipReader オブジェクトを与えられてブロックが実行されます。
        ja| ブロックの実行が終了すると、GzipReader オブジェクトは自動的に
        ja| クローズされます。関連付けられている IO オブジェクトまで
        ja| クローズしたくない時は、ブロック中で引数つきの
        ja| ((<Zlib::GzipFile#close>)) メソッドを明示的に呼び出して下さい。
        #|
        en|    If this method is called with a block, the block will be
        en|    executed with a newly created GzipReader object, just like
        en|    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 explicitly
        en|    ((<Zlib::GzipFile#close>)) method with an argument in the block.

--- Zlib::GzipReader.open(filename)
--- Zlib::GzipReader.open(filename) {|gz| ... }
        ja| ((|filename|)) で指定されるファイルを gzip ファイルとして
        ja| オープンします。GzipReader オブジェクトを返します。
        ja| その他詳細は ((<Zlib::GzipReader.new>)) と同じです。
        #|
        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>)).

=== メソッド:

--- Zlib::GzipReader#eof
--- Zlib::GzipReader#eof?
        ja| 圧縮データの終端に達した場合真を返します。
        ja| フッターが読み込まれていなくても真を返すことに注意して下さい。
        #|
        en|    Returns true if the object reaches the end of ompressed data.
        en|    Note that eof? does ((*not*)) return true when reaches the
        en|    end of ((*file*)).

--- Zlib::GzipReader#pos
--- Zlib::GzipReader#tell
        ja| 現在までに展開したデータの長さの合計を返します。
        ja| ファイルポインタの位置ではないことに注意して下さい。
        #|
        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)
        ja| IO クラスの同名メソッドと同じですが、gzip ファイル中に
        ja| エラーがあった場合 ((<Zlib::Error>)) 例外や
        ja| ((<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.

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

        ja|| * EOF (圧縮データの最後) を越えて読み込み要求を受けた時。
        ja||   すなわち ((<Zlib::GzipReader#read>)),
        ja||   ((<Zlib::GzipReader#gets>)) メソッド等が nil を返す時。
        ja|| * EOF まで読み込んだ後、((<Zlib::GzipFile#close>)) メソッドが
        ja||   呼び出された時。
        ja|| * EOF まで読み込んだ後、((<Zlib::GzipReader#unused>)) メソッドが
        ja||   呼び出された時。
        #|
        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.
        en|| * When ((<Zlib::GzipFile#close>)) method is called after
        en||   the object reaches the end of file.
        en|| * When ((<Zlib::GzipReader#unused>)) method is called after
        en||   the object reaches the end of file.

--- Zlib::GzipReader#rewind
        ja| ファイルポインタを ((<Zlib::GzipReader.new>)) を呼び出した直後の
        ja| 時点に戻します。関連付けられている IO オブジェクトに
        ja| 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
        ja| gzip フォーマットの解析のために読み込んだ余剰のデータを返します。
        ja| 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

ja| gzip 形式の圧縮ファイルを書き出すラッパークラス。
ja| IO クラスのインスタンス (又は IO クラスのインスタンスと同じメソッドを
ja| 持つオブジェクト) と関連付けて使用します。
#|
en|    The class for writing a gzipped file. GzipWriter should be used with
en|    associate with an instance of IO class (or an object which has
en|    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

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

=== スーパークラス:

* ((<Zlib::GzipFile>))

=== クラスメソッド:

--- Zlib::GzipWriter.new(io[, level[, strategy]])
--- Zlib::GzipWriter.new(io[, level[, strategy]]) {|gz| ... }
        ja| ((|io|)) と関連付けられた GzipWriter オブジェクトを作成します。
        ja| ((|level|)), ((|strategy|)) は ((<Zlib::Deflate.new>)) と同じです。
        ja| GzipWriter オブジェクトは ((|io|)) に gzip 形式のデータを
        ja| 逐次ライトします。((|io|)) には少なくとも、IO#write と
        ja| 同じ動作をする 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.

        ja| ブロックを指定して呼び出した場合は、File.open と同じように
        ja| GzipWriter オブジェクトを与えられてブロックが実行されます。
        ja| ブロックの実行が終了すると、GzipWriter オブジェクトは自動的に
        ja| クローズされます。関連付けられている IO オブジェクトまで
        ja| クローズしたくない時は、ブロック中で引数つきの
        ja| ((<Zlib::GzipFile#close>)) メソッドを明示的に呼び出して下さい。
        #|
        en|    If new is called with a block, the block will be executed
        en|    with a newly created GzipWriter object, just like File.open.
        en|    The GzipWriter object will be closed automatically after
        en|    executing the block. If you want to keep the associated IO
        en|    object opening, you may call explicitly
        en|    ((<Zlib::GzipFile#close>)) method with an argument
        en|    in the block explicitly.

--- Zlib::GzipWriter.open(filename[, level[, strategy]])
--- Zlib::GzipWriter.open(filename[, level[, strategy]]) {|gz| ... }
        ja| ((|filename|)) で指定されるファイルを gzip 圧縮データの
        ja| 書き出し用にオープンします。GzipWriter オブジェクトを返します。
        ja| その他詳細は ((<Zlib::GzipWriter.new>)) と同じです。
        #|
        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>)).

=== メソッド:

--- Zlib::GzipWriter#close([dont_close_io])
        ja| フッターを書き出し、GzipWriter オブジェクトをクローズします。
        #|
        en|    Writes the gzip file footer and closes the GzipWriter object.

        ja| ((*注意: Ruby の finalizer の制約のため、GzipWriter オブジェクトは
        ja| 必ずクローズしてください。そうしなければフッターを書き出すことが
        ja| できず、壊れた 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
        ja| 現在までに圧縮したデータの長さの合計を返します。
        ja| ファイルポインタの位置ではないことに注意して下さい。
        #|
        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)
        ja| IO クラスの同名メソッドと同じ。
        #|
        en|    Same as IO.

--- Zlib::GzipWriter#flush([flush])
        ja| まだ書き出されていないデータをフラッシュします。
        ja| ((|flush|)) は ((<Zlib::Deflate#deflate>)) と同じです。
        ja| 省略時は ((<Zlib::SYNC_FLUSH>)) が使用されます。
        ja| ((|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
        ja| gzip ファイルのヘッダーに記録する最終更新時間を指定します。
        ja| ((<Zlib::GzipWriter#write>)) 等の書き込み系メソッドを
        ja| 呼んだ後で指定しようとすると ((<Zlib::GzipFile::Error>)) 例外が
        ja| 発生します。
        #|
        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
        ja|  gzip ファイルのヘッダーに記録する元ファイル名を指定します。
        ja|  ((<Zlib::GzipWriter#write>)) 等の書き込み系メソッドを
        ja|  呼んだ後で指定しようとすると ((<Zlib::GzipFile::Error>)) 例外が
        ja|  発生します。
        #|
        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
        ja| gzip ファイルのヘッダーに記録するコメントを指定します。
        ja| ((<Zlib::GzipWriter#write>)) 等の書き込み系メソッドを
        ja| 呼んだ後で指定しようとすると ((<Zlib::GzipFile::Error>)) 例外が
        ja| 発生します。
        #|
        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.



ja| == 0.4.0 からの変更点
en| == Changes from 0.4.0

ja| 全体的に書き換えてます。これで全部…だといいなぁ(汗::
#|
en|    Almost all the code are rewritten.
en|    I hope all changes are enumerated below :-)

ja|| * クラス名、メソッド名の変更。全てのクラスと定数は ((<Zlib>)) 以下に
ja||   移しました。0.4.0 との互換性のために以前のものも残してあります。
#|
en|| * The names of almost classes and some methods are changed.
en||   All classes and constants are now defined under module ((<Zlib>)).
en||   The obsoleted names are also available for backward compatibility.

ja||   * クラス
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>))
ja||   * 定数
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>))
ja||   * メソッド
en||   * Methods
        * Zlib::ZStream#flush_out -> ((<Zlib::ZStream#flush_next_out>))

ja|| * ((<Zlib::Error#next_in>)) の追加。
ja|| * 入力側 (next_in) にもバッファを設ける。
ja|| * NeedDict エラーは特別に処理するようにした。
ja|| * ((<Zlib::GzipReader#unused>)) はクローズ後は nil を返す。
ja|| * ((<Zlib::GzipWriter#close>)) の義務化。finalizer での segv を
ja||   回避。 ((<[ruby-dev:11915]|URL:http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-dev/11915>))
ja|| * new と initialize を分けた。
ja|| * deflateInit2, inflateInit2 に渡す引数の sanity check を
ja||   しないようにした。
ja|| * ((<Zlib::GzipWriter#puts>)) の挙動は Ruby-1.7 に合わせることにした。
ja|| * 全関数を static に。
#|
en|| * ((<Zlib::Error#next_in>)) method is added.
en|| * Made buffer for input (next_in).
en|| * Process NeedDict error specially.
en|| * ((<Zlib::GzipReader#unused>)) returns nil after closing.
en|| * Now you are up to call ((<Zlib::GzipWriter#close>)) explicitly
en||   to avoid segv in finalizer. ((<[ruby-dev:11915]|URL:http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-dev/11915>))
en|| * divided intialize from new.
en|| * remove sanity checks for arguments for deflateInit2 and inflateInit2.
en|| * adapted the behavior of ((<Zlib::GzipWriter#puts>)) to Ruby-1.7.
en|| * Made all functions static.


=end
