liblzma 0.2 → 0.3

data/README.txt

@@ -1,43 +1,42 @@
-# encoding:utf-8
 
 = liblzma for Ruby
 
 - AUTHOR : dearblue
 - MAIL : dearblue@users.sourceforge.jp
 - LICENSE : 2-clause BSD License (二条項BSDライセンス)
-- PROJECTPAGE : http://sourceforge.jp/projects/rutsubo/
+- PROJECT PAGE : http://sourceforge.jp/projects/rutsubo/
 
 This document is written in Japanese.
 
 
 == はじめに
 
-xzユーティリティに含まれるliblzmaのRubyバインディングです。
+xz ユーティリティに含まれる liblzma の Ruby バインディングです。
 
-gemパッケージになっており、『gem install liblzma-0.2.gem』でビルド、インストールが完了します。
+gemパッケージになっており、『gem install liblzma-0.3.gem』でビルド、インストールが完了します。
 
-MinGW32およびFreeBSD 9.0R i386で動作確認を行っています。
+MinGW32 および FreeBSD 9.0R i386 で動作確認を行っています。
 
-MinGW32向けにはバイナリパッケージも用意してあります (もしかしたらruby-mswin32でも動作するかもしれません)。
+MinGW32 向けにはバイナリパッケージも用意してあります (もしかしたら ruby-mswin32 でも動作するかもしれません)。
 
-FreeBSD 9.0R i386 上では標準コンパイラであるGCCのほかにllvm clangでもビルド可能なことを確認してあります。
+FreeBSD 9.0R i386 上では標準コンパイラである GCC のほかに llvm clang でもビルド可能なことを確認してあります。
 
 
 == 利用できる主な機能
 
-※カッコ内は、本来のliblzmaが提供する関数を示す
+※カッコ内は、本来の liblzma が提供する関数を示す
 
-* LZMA::Stream::Encoder/Decoder (lzma_stream_encoder / lzma_stream_decoder)
-* LZMA::Stream::RawEncoder/RawDecoder (lzma_raw_encoder / lzma_raw_decoder)
-* LZMA::Utils.crc32/crc64 (lzma_crc32 / lzma_crc64)
-* LZMA::Filter::LZMA1/LZMA2/Delta
+- LZMA::Stream::Encoder / Decoder (lzma_stream_encoder / lzma_stream_decoder)
+- LZMA::Stream::RawEncoder / RawDecoder (lzma_raw_encoder / lzma_raw_decoder)
+- LZMA::Filter::LZMA1 / LZMA2 / Delta
+- LZMA::Utils.crc32 / crc64 (lzma_crc32 / lzma_crc64)
 
 
 == 実際に利用するには
 
-まともな文書化が出来ていないため、gemパッケージ内の『samples』ディレクトリに含まれる各サンプルを頼りにして下さい。
+まともな文書化が出来ていないため、gem パッケージ内の『samples』ディレクトリに含まれる各サンプルを頼りにして下さい。
 
 
 == ライセンスについて
 
-liblzma for Ruby は、二条項BSDライセンスの下で利用できます。
+liblzma for Ruby は、二条項 BSD ライセンスの下で利用できます。

data/ext/extconf.rb

@@ -1,7 +1,23 @@
+#!ruby
+
+require "optparse"
+
+opt = OptionParser.new
+
+staticlink = nil
+opt.on("-s", "link liblzma.a as static library") { staticlink = true }
+
+opt.parse!
+
+
 require "mkmf"
 
 have_header "lzma.h" or raise "need lzma.h"
 have_library "lzma" or raise "need liblzma.a"
+if staticlink
+  # 静的ライブラリリンクを優先する
+  $libs = ["-Wl,-dn,-llzma", "-Wl,-llzma", $libs].join(" ")
+end
 create_makefile "liblzma"
 
 # Makefile から、『-L.』を取り除く

data/ext/liblzma.c

@@ -1,8 +1,10 @@
+/* encoding:utf-8 */
+
 /*
  * liblzma.c -
- * Author::    dearblue <dearblue@sourceforge.jp>
- * Copyright:: Copyright (c) 2010 dearblue
- * License::   Distributed under the 2-clause BSD License
+ * - Author:    dearblue <dearblue@sourceforge.jp>
+ * - Copyright: Copyright (c) 2010 dearblue
+ * - License:   Distributed under the 2-clause BSD License
  */
 
 #include <ruby.h>
@@ -14,7 +16,7 @@ static VALUE mLZMA;
 
 
 static VALUE symDICTSIZE;
-static VALUE symPRESETDICT;
+static VALUE symDICT;
 static VALUE symLC;
 static VALUE symLP;
 static VALUE symPB;
@@ -25,12 +27,25 @@ static VALUE symDEPTH;
 static VALUE symCHECK;
 
 
+// rdoc に対して定義されているものと錯覚させるマクロ
+#define RDOC(...)
+
+
 static inline int
 lzma_isfailed(lzma_ret status)
 {
     return status != 0;
 }
 
+#define LZMA_TEST(STATUS)                                       \
+    {                                                           \
+        lzma_ret _status = (STATUS);                            \
+        if (lzma_isfailed(_status)) {                           \
+            VALUE exc = lookup_exception(_status);              \
+            rb_exc_raise(rb_exc_new3(exc, rb_class_name(exc))); \
+        }                                                       \
+    }                                                           \
+
 
 // SECTION: LZMA::Constants
 
@@ -178,44 +193,189 @@ setup_lzma_preset(size_t preset)
     lzma_options_lzma *lzma = xcalloc(sizeof(lzma_options_lzma), 1);
     if (lzma_lzma_preset(lzma, preset)) {
         rb_raise(rb_eArgError,
-                 "wrong preset level (%d for 0..9) or wrong flag bit(s) (%08x)",
+                 "wrong preset level (%d for 0..9) or wrong flag bit(s) (0x%08x)",
                  preset & LZMA_PRESET_LEVEL_MASK,
                  preset & ~LZMA_PRESET_LEVEL_MASK & ~LZMA_PRESET_EXTREME);
     }
     return (void *)(lzma);
 }
 
-static const char PRIVATE_DICTPRESET[] = "dict_preset";
 
-static inline void
-lzma_set_dict_0(lzma_options_lzma *filter, VALUE dict, VALUE self)
-{
-    if (NIL_P(dict)) {
-        filter->preset_dict = NULL;
-        filter->preset_dict_size = 0;
-    } else {
-        if (TYPE(dict) != T_STRING) {
-            rb_raise(rb_eTypeError, "%s", "dict is not a String or nil");
-        }
-        dict = rb_str_new_frozen(dict);
-        filter->preset_dict = (uint8_t *)(RSTRING_PTR(dict));
-        filter->preset_dict_size = RSTRING_LEN(dict);
-    }
-    rb_iv_set(self, PRIVATE_DICTPRESET, dict);
-}
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#dict
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#dict -> string or nil
+ *
+ * 定義済み辞書を取得します。
+ *
+ * [RETURN] 定義済み辞書が定義されている場合は文字列が返ります。定義されていなければ +nil+ が返ります。
+ *
+ *          エンコード情報は無視されます (常に Encoding::BINARY として扱われます)。呼び出し側で統一しておくべきです。
+ *
+ *          返される文字列は定義辞書の複成体です。変更しても定義情報には反映されません。+#dict=+ と併せて利用して下さい。
+ */
 
-static VALUE
-lzma_set_dict(VALUE self, VALUE dict)
-{
-    lzma_set_dict_0((lzma_options_lzma *)getfilter(self)->options, dict, self);
-    return self;
-}
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#dict=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#dict=(dict)
+ *
+ * 定義済み辞書を定義します。
+ *
+ * [dict]   定義済み辞書として文字列を与えます。定義を無効にする (定義済み辞書を利用しない) には、+nil+ を与えます。
+ *
+ *          エンコード情報は無視されます (常に Encoding::BINARY として扱われます)。呼び出し側で統一しておくべきです。
+ *
+ *          与えた文字列は内部で複写され、元の文字列とは独立します。文字列の変更を反映したい場合はその都度 +#dict=+ を呼ぶ必要があります。
+ *
+ * [RETURN] 自身 (self) を返します。
+ */
 
-static VALUE
-lzma_get_dict(VALUE self)
-{
-    return rb_str_new_shared(rb_iv_get(self, PRIVATE_DICTPRESET));
-}
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#dictsize
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#dictsize -> integer
+ *
+ * 辞書の大きさをバイト値として取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#dictsize=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#dictsize=(size) -> self
+ *
+ * 辞書の大きさをバイト値として設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#lc
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#lc -> integer
+ *
+ * lc 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#lc=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#lc=(value) -> self
+ *
+ * lc 値を設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#lp
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#lp -> integer
+ *
+ * lp 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#lp=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#lp=(value) -> self
+ *
+ * lp 値を設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#pb
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#pb -> integer
+ *
+ * pb 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#pb=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#pb=(value) -> self
+ *
+ * pb 値を設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#mode
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#mode -> integer
+ *
+ * mode 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#mode=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#mode=(value) -> self
+ *
+ * mode 値を設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#nice
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#nice -> integer
+ *
+ * nice 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#nice=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#nice=(value) -> self
+ *
+ * nice 値を設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#mf
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#mf -> integer
+ *
+ * mf 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#mf=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#mf=(value) -> self
+ *
+ * mf 値を設定します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#depth
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#depth -> integer
+ *
+ * depth 値を取得します。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#depth=
+ *
+ * call-seq:
+ * LZMA::Filter::BasicLZMA#depth=(value) -> self
+ *
+ * depth 値を設定します。
+ */
 
 
 #define DEFINE_ACCESSOR_ENTITY(NAME, MEMBER, DEFAULT)                              \
@@ -242,17 +402,68 @@ lzma_get_dict(VALUE self)
         return UINT2NUM(((lzma_options_lzma *)getfilter(self)->options)->MEMBER);  \
     }                                                                              \
 
-DEFINE_ACCESSOR_ENTITY(dictsize,   dict_size,   LZMA_DICT_SIZE_DEFAULT) // lzma_set_dictsize_0, lzma_set_dictsize, lzma_set_lc
-DEFINE_ACCESSOR_ENTITY(lc,         lc,          LZMA_LC_DEFAULT)
-DEFINE_ACCESSOR_ENTITY(lp,         lp,          LZMA_LP_DEFAULT)
-DEFINE_ACCESSOR_ENTITY(pb,         pb,          LZMA_PB_DEFAULT)
-DEFINE_ACCESSOR_ENTITY(mode,       mode,        LZMA_MODE_NORMAL)
-DEFINE_ACCESSOR_ENTITY(nice,       nice_len,    64)
-DEFINE_ACCESSOR_ENTITY(mf,         mf,          LZMA_MF_BT4)
-DEFINE_ACCESSOR_ENTITY(depth,      depth,       0)
+static ID IDdictpreset;
+
+static inline void
+lzma_set_dict_nil(lzma_options_lzma *filter)
+{
+    filter->preset_dict = NULL;
+    filter->preset_dict_size = 0;
+}
+
+static inline void
+lzma_set_dict_string(lzma_options_lzma *filter, VALUE dict)
+{
+    dict = rb_str_new_frozen(dict);
+    filter->preset_dict = (uint8_t *)(RSTRING_PTR(dict));
+    filter->preset_dict_size = RSTRING_LEN(dict);
+}
+
+static inline void
+lzma_set_dict_0(lzma_options_lzma *filter, VALUE dict, VALUE self)
+{
+    if (NIL_P(dict)) {
+        lzma_set_dict_nil(filter);
+    } else if (TYPE(dict) == T_STRING) {
+        if (RSTRING_LEN(dict) > 0) {
+            lzma_set_dict_string(filter, dict);
+        } else {
+            lzma_set_dict_nil(filter);
+        }
+    } else {
+        rb_raise(rb_eTypeError, "%s", "dict is not a String or nil");
+    }
+
+    rb_ivar_set(self, IDdictpreset, dict);
+}
+
+static VALUE
+lzma_set_dict(VALUE self, VALUE dict)
+{
+    lzma_set_dict_0((lzma_options_lzma *)getfilter(self)->options, dict, self);
+    return self;
+}
+
+static VALUE
+lzma_get_dict(VALUE self)
+{
+    VALUE dict = rb_attr_get(self, IDdictpreset);
+    if (!NIL_P(dict)) { dict = rb_str_new_shared(dict); }
+    return dict;
+}
+
+DEFINE_ACCESSOR_ENTITY(dictsize,   dict_size,   LZMA_DICT_SIZE_DEFAULT); // lzma_set_dictsize_0, lzma_set_dictsize, lzma_set_lc
+DEFINE_ACCESSOR_ENTITY(lc,         lc,          LZMA_LC_DEFAULT);
+DEFINE_ACCESSOR_ENTITY(lp,         lp,          LZMA_LP_DEFAULT);
+DEFINE_ACCESSOR_ENTITY(pb,         pb,          LZMA_PB_DEFAULT);
+DEFINE_ACCESSOR_ENTITY(mode,       mode,        LZMA_MODE_NORMAL);
+DEFINE_ACCESSOR_ENTITY(nice,       nice_len,    64);
+DEFINE_ACCESSOR_ENTITY(mf,         mf,          LZMA_MF_BT4);
+DEFINE_ACCESSOR_ENTITY(depth,      depth,       0);
 
 #undef DEFINE_ACCESSOR_ENTITY
 
+
 static void *
 setup_lzma(VALUE obj, uint32_t preset,
            VALUE dictsize, VALUE dictpreset, VALUE lc, VALUE lp, VALUE pb,
@@ -260,7 +471,7 @@ setup_lzma(VALUE obj, uint32_t preset,
 {
     lzma_options_lzma lzma = { 0 };
     if (lzma_lzma_preset(&lzma, preset) != 0) {
-        rb_raise(eBadPreset, "bad preset (%08x)", preset);
+        rb_raise(eBadPreset, "bad preset (0x%08x)", preset);
     }
 
     if (RTEST(dictpreset)) { lzma_set_dict_0(&lzma, dictpreset, obj); }
@@ -306,12 +517,12 @@ getpreset(VALUE preset)
 
 /*
  * call-seq:
- *  LZMA::Filter.lzma1(....)
+ *  LZMA::Filter.lzma1(...)
  *
- * LZMA::Filter::LZMA1.newを呼ぶための補助機構である
+ * LZMA::Filter::LZMA1.newを呼ぶための補助機構です。
  *
- * LZMA::Filter::LZMA1クラスの .new や #initialize を書き換えた場合はそれに従う
- * (あくまで .new を呼ぶだけである)
+ * LZMA::Filter::LZMA1クラスの .new や #initialize を書き換えた場合はそれに従います
+ * (あくまで .new を呼ぶだけです)。
  */
 static VALUE
 lzma1_new(int argc, VALUE argv[], VALUE self)
@@ -323,10 +534,10 @@ lzma1_new(int argc, VALUE argv[], VALUE self)
  * call-seq:
  *  LZMA::Filter.lzma2(...)
  *
- * LZMA::Filter::LZMA2.new を呼ぶための補助機構である
+ * LZMA::Filter::LZMA2.new を呼ぶための補助機構です。
  *
- * LZMA::Filter::LZMA2クラスの .new や #initialize を書き換えた場合はそれに従う
- * (あくまで .new を呼ぶだけである)
+ * LZMA::Filter::LZMA2クラスの .new や #initialize を書き換えた場合はそれに従います
+ * (あくまで .new を呼ぶだけです)。
  */
 static VALUE
 lzma2_new(int argc, VALUE argv[], VALUE self)
@@ -336,12 +547,12 @@ lzma2_new(int argc, VALUE argv[], VALUE self)
 
 /*
  * call-seq:
- *  LZMA::Filter.delta(....)
+ *  LZMA::Filter.delta(...)
  *
- * LZMA::Filter::Delta.newを呼ぶための補助機構である
+ * LZMA::Filter::Delta.new を呼ぶための補助機構です。
  *
- * LZMA::Filter::Deltaクラスの .new や #initialize を書き換えた場合はそれに従う
- * (あくまで .new を呼ぶだけである)
+ * LZMA::Filter::Deltaクラスの .new や #initialize を書き換えた場合はそれに従います
+ * (あくまで .new を呼ぶだけです)。
  */
 static VALUE
 delta_new(int argc, VALUE argv[], VALUE self)
@@ -350,7 +561,6 @@ delta_new(int argc, VALUE argv[], VALUE self)
 }
 
 
-
 static inline VALUE
 filter_alloc(VALUE klass, lzma_vli id)
 {
@@ -383,13 +593,14 @@ delta_alloc(VALUE klass)
  * call-seq:
  *  LZMA::Filter::Delta.new(dist = LZMA::DELTA_DIST_MIN)
  *
- * 差分フィルタ設定オブジェクトを返す。
+ * 差分フィルタ設定オブジェクトを返します。
  *
- * distは1要素あたりのバイト長で、1以上を指定する。
+ * distは1要素あたりのバイト長で、1以上255以下を指定できます。
  *
- * 使用する場合多くの場合1で十分だろうし、音楽CDの音声データであれば2を指定するのがいいだろう。
+ * NOTE::
+ *  使用する場合多くの場合1で十分と思われますが、音楽CDの音声データであれば1サンプル2バイトであるため2が有効でしょう。
  *
- * しかし元のデータによっては圧縮効率を低下させることがあるため、常に適用することはしないほうがいい。
+ *  しかし元のデータによっては圧縮効率を低下させることがあるため、実際に適用するべきかはデータの特性によって検証するのが好ましいです。
  */
 static VALUE
 delta_init(int argc, VALUE argv[], VALUE self)
@@ -408,27 +619,24 @@ delta_init(int argc, VALUE argv[], VALUE self)
 
 /*
  * call-seq:
- *  LZMA::Filter::BasicLZMA.new(preset = LZMA::PRESET_DEFAULT, opts = { .... } ) -> filter
+ *  LZMA::Filter::BasicLZMA.new(preset = LZMA::PRESET_DEFAULT, ... ) -> filter
  *
- * フィルタ設定オブジェクトを返す。
+ * LZMA フィルタ設定オブジェクトを初期化します。
  *
- * この段階で各値の確認を行うことはせず、*encoderに渡すときに初めて確認される
+ * この段階で各値の確認を行うことはせず、*encoderに渡すときに初めて確認されます。
  *
- * 引数::
- *  引数は、presetは整数で、続くoptsはハッシュであり、細かい調整を行う場合に指定する。
- *
- *  どちらも任意に省略可能であり、presetを省略してoptsを指定することも可能である。
- *
- *  preset:: プリセット値 (≒圧縮レベル) を0-9の範囲で指定する。既定値はLZMA::PRESET_DEFAULTである。
- *  dictsize:: 既定値はLZMA::DICT_SIZE_DEFAULT
- *  presetdict:: 既定値はnil
- *  lc:: 既定値はLZMA::LC_DEFAULT
- *  lp:: 既定値はLZMA::LP_DEFAULT
- *  pb:: 既定値はLZMA::PB_DEFAULT
- *  mode:: 既定値はLZMA::MODE_NORMAL
- *  nice:: 既定値はLZMA::NICE_DEFAULT
- *  mf:: 既定値はLZMA::MF_BT4
- *  depth:: 既定値はLZMA::DEPTH_DEFAULT
+ * [preset]     プリセット値 (≒圧縮レベル) を 0-9 の範囲で指定し、任意で LZMA::PRESET_EXTREME を論理和で組み合わせることが出来ます。既定値はLZMA::PRESET_DEFAULTとなります。
+ * [dictsize]   辞書の大きさをバイト値で指定します。既定値は preset によって変化します。
+ * [dict]       定義済み辞書を指定します。既定値は nil です。
+ * [lc]         既定値は preset によって変化します。
+ * [lp]         既定値は preset によって変化します。
+ * [pb]         既定値は preset によって変化します。
+ * [mode]       既定値は preset によって変化します。
+ * [nice]       既定値は preset によって変化します。
+ * [mf]         既定値は preset によって変化します。
+ * [depth]      既定値は preset によって変化します。
+ * [RETURN]     フィルタオブジェクト
+ * [EXCEPTIONS] (NO DOCUMENT)
  */
 static VALUE
 lzma_init(int argc, VALUE argv[], VALUE self)
@@ -442,7 +650,7 @@ lzma_init(int argc, VALUE argv[], VALUE self)
     } else {
         filter->options = setup_lzma(self, getpreset(preset),
                                      rb_hash_lookup(opts, symDICTSIZE),
-                                     rb_hash_lookup(opts, symPRESETDICT),
+                                     rb_hash_lookup(opts, symDICT),
                                      rb_hash_lookup(opts, symLC),
                                      rb_hash_lookup(opts, symLP),
                                      rb_hash_lookup(opts, symPB),
@@ -455,13 +663,33 @@ lzma_init(int argc, VALUE argv[], VALUE self)
 }
 
 /*
- * Document-method: LZMA::Filter::BasicLZMA#dictsize
+ * Document-class: LZMA::Filter
+ *
+ * LZMA::Filter クラスは、各圧縮器や伸張器の生成時に用いるフィルタ情報を取り扱います。
+ *
+ * liblzma で定義されているフィルタはそれぞれ LZMA::Filter::LZMA1 /
+ * LZMA::Filter::LZMA2 / LZMA::Filter::Delta として定義されています。
+ *
+ * これらのクラスについてはそれぞれの文書を見てください。
+ */
+
+/*
+ * Document-class: LZMA::Filter::BasicLZMA
+ *
+ * LZMA::Filter::LZMA1 と LZMA::Filter::LZMA2 の基本となるクラスです。
+ *
+ * allocator を持たないため、このクラス自身はインスタンスを作成することが出来ません。
+ */
+
+/*
+ * Document-method: LZMA::Filter::BasicLZMA#dictsize -> integer
  *
  * call-seq:
  *  LZMA::Filter::BasicLZMA#dictsize -> 辞書サイズ (バイト長)
  *
  * 様々なフィルタ値の設定・取り出しを行う
  */
+
 static void
 setup_filter(void)
 {
@@ -484,21 +712,25 @@ setup_filter(void)
     rb_define_alloc_func(cDelta, delta_alloc);
     rb_define_method(cDelta, "initialize", delta_init, -1);
 
-#define DEF_ACCESSOR(CLASS, NAME)                             \
-    rb_define_method(CLASS, #NAME, lzma_get_ ## NAME, 0);     \
-    rb_define_method(CLASS, #NAME "=", lzma_set_ ## NAME, 1); \
-
-    DEF_ACCESSOR(cBasicLZMA, dictsize);
-    DEF_ACCESSOR(cBasicLZMA, dict);
-    DEF_ACCESSOR(cBasicLZMA, lc);
-    DEF_ACCESSOR(cBasicLZMA, lp);
-    DEF_ACCESSOR(cBasicLZMA, pb);
-    DEF_ACCESSOR(cBasicLZMA, mode);
-    DEF_ACCESSOR(cBasicLZMA, nice);
-    DEF_ACCESSOR(cBasicLZMA, mf);
-    DEF_ACCESSOR(cBasicLZMA, depth);
-
-#undef DEF_ACCESSOR
+
+    rb_define_method(cBasicLZMA, "dictsize",    lzma_get_dictsize, 0);
+    rb_define_method(cBasicLZMA, "dictsize=",   lzma_set_dictsize, 1);
+    rb_define_method(cBasicLZMA, "dict",        lzma_get_dict, 0);
+    rb_define_method(cBasicLZMA, "dict=",       lzma_set_dict, 1);
+    rb_define_method(cBasicLZMA, "lc",          lzma_get_lc, 0);
+    rb_define_method(cBasicLZMA, "lc=",         lzma_set_lc, 1);
+    rb_define_method(cBasicLZMA, "lp",          lzma_get_lp, 0);
+    rb_define_method(cBasicLZMA, "lp=",         lzma_set_lp, 1);
+    rb_define_method(cBasicLZMA, "pb",          lzma_get_pb, 0);
+    rb_define_method(cBasicLZMA, "pb=",         lzma_set_pb, 1);
+    rb_define_method(cBasicLZMA, "mode",        lzma_get_mode, 0);
+    rb_define_method(cBasicLZMA, "mode=",       lzma_set_mode, 1);
+    rb_define_method(cBasicLZMA, "nice",        lzma_get_nice, 0);
+    rb_define_method(cBasicLZMA, "nice=",       lzma_set_nice, 1);
+    rb_define_method(cBasicLZMA, "mf",          lzma_get_mf, 0);
+    rb_define_method(cBasicLZMA, "mf=",         lzma_set_mf, 1);
+    rb_define_method(cBasicLZMA, "depth",       lzma_get_depth, 0);
+    rb_define_method(cBasicLZMA, "depth=",      lzma_set_depth, 1);
 }
 
 
@@ -512,15 +744,6 @@ static VALUE cRawEncoder;
 static VALUE cRawDecoder;
 
 
-#define LZMA_TEST(STATUS)                                       \
-    {                                                           \
-        lzma_ret _status = (STATUS);                            \
-        if (lzma_isfailed(_status)) {                           \
-            VALUE exc = lookup_exception(_status);              \
-            rb_exc_raise(rb_exc_new3(exc, rb_class_name(exc))); \
-        }                                                       \
-    }                                                           \
-
 static inline void
 filter_copy(lzma_filter *dest, VALUE filter)
 {
@@ -596,13 +819,6 @@ stream_update_2(struct stream_update_args *args)
     return rb_thread_blocking_region((VALUE (*)(void *))stream_update_1, args, RUBY_UBF_IO, NULL);
 }
 
-static inline VALUE
-stream_update_3(VALUE src)
-{
-    rb_str_unlocktmp(src);
-    return Qnil;
-}
-
 static inline VALUE
 stream_update_0(lzma_stream *stream, lzma_action action, VALUE src)
 {
@@ -613,7 +829,7 @@ stream_update_0(lzma_stream *stream, lzma_action action, VALUE src)
             stream, action,
             (const uint8_t *)RSTRING_PTR(src), RSTRING_LEN(src),
         };
-        return rb_ensure(stream_update_2, (VALUE)&args, stream_update_3, src);
+        return rb_ensure(stream_update_2, (VALUE)&args, rb_str_unlocktmp, src);
     } else {
         struct stream_update_args args = {
             stream, action, NULL, 0,
@@ -706,7 +922,17 @@ filter_setup(lzma_filter filter[LZMA_FILTERS_MAX + 1], VALUE filters0[], VALUE *
 }
 
 
-// LZMA::Stream.encoder(filter1, filter2, ...., filterN, check: CRC64)
+/*
+ * call-seq:
+ *  LZMA::Stream::Encoder.new(filter1 [ , filter2 [ , filter3 [ , filter4 ] ] ], check: CHECK_CRC64) -> encoder
+ * 
+ * 圧縮器を生成します。圧縮されたデータストリームは xz ファイルフォーマットです。
+ *
+ * [filter1, filter2, filter3, filter4] LZMA::Filter インスタンス。最低一つを必要とします。
+ * [check] チェックメソッド。CHECK_NONE CHECK_CRC32 CHECK_CRC64 CHECK_SHA256 のいずれかの定数を与えます。
+ * [RETURN] 生成された圧縮器
+ * [EXCEPTIONS] (NO DOCUMENTS)
+ */
 static VALUE
 encoder_init(int argc, VALUE argv[], VALUE self)
 {
@@ -731,7 +957,7 @@ encoder_init(int argc, VALUE argv[], VALUE self)
 
 /*
  * call-seq:
- *  LZMA::Stream::AutoDecoder.initialize(memlimit = nil, flags = nil)
+ *  LZMA::Stream::AutoDecoder.new(memlimit = nil, flags = nil)
  */
 static VALUE
 autodecoder_init(int argc, VALUE argv[], VALUE self)
@@ -752,7 +978,7 @@ autodecoder_init(int argc, VALUE argv[], VALUE self)
 
 /*
  * call-seq:
- *  LZMA::Stream::Decoder.initialize(memlimit = nil, flags = nil)
+ *  LZMA::Stream::Decoder.new(memlimit = nil, flags = nil)
  */
 static VALUE
 decoder_init(int argc, VALUE argv[], VALUE self)
@@ -773,9 +999,9 @@ decoder_init(int argc, VALUE argv[], VALUE self)
 
 /*
  * call-seq:
- *  LZMA::Stream::RawEncoder.initialize(filter1 [ , filter2 [ , .... ] ]) -> encoder
+ *  LZMA::Stream::RawEncoder.new(filter1 [ , filter2 [ , .... ] ]) -> encoder
  *
- * 生の (xzヘッダなどの付かない) LZMA1/2ストリームを構成する圧縮器機を生成する。
+ * 生の (xzヘッダなどの付かない) LZMA1/2ストリームを構成する圧縮器を生成する。
  *
  * filterは1つ以上4つまでを与える。
  */
@@ -797,7 +1023,7 @@ rawencoder_init(int argc, VALUE argv[], VALUE self)
 
 /*
  * call-seq:
- *  LZMA::Stream::RawDecoder.initialize(filter1 [ , filter2 [ , .... ] ])
+ *  LZMA::Stream::RawDecoder.new(filter1 [ , filter2 [ , .... ] ])
  */
 static VALUE
 rawdecoder_init(int argc, VALUE argv[], VALUE self)
@@ -896,60 +1122,62 @@ setup_index(void)
 
 // SECTION: LZMA::Utils
 
-struct utils_crc32_args
+struct crc_args
 {
     const uint8_t *ptr;
     size_t len;
-    uint32_t crc;
+    VALUE crc;
+    VALUE (*crc_update)(struct crc_args *args);
 };
 
 static VALUE
-utils_crc32_update(struct utils_crc32_args *args)
+crc_calc_try(struct crc_args *args)
 {
-    return UINT2NUM(lzma_crc32(args->ptr, args->len, args->crc));
+    return rb_thread_blocking_region((VALUE (*)(void *))(args->crc_update), args, RUBY_UBF_IO, NULL);
 }
 
-/*
- * call-seq:
- *  LZMA::Utils.crc32(string, crc = 0)
- *
- * liblzmaに含まれるlzma_crc32を呼び出します。
- */
-static VALUE
-utils_crc32(int argc, VALUE argv[], VALUE self)
+static inline VALUE
+crc_calc(VALUE (*crc_update)(struct crc_args *args), int argc, VALUE argv[])
 {
     VALUE src, crc;
     rb_scan_args(argc, argv, "11", &src, &crc);
-
     StringValue(src);
     rb_str_locktmp(src);
 
-    struct utils_crc32_args args = {
+    struct crc_args args = {
         (const uint8_t *)RSTRING_PTR(src),
         RSTRING_LEN(src),
-        NIL_P(crc) ? 0 : NUM2UINT(crc),
+        NIL_P(crc) ? INT2FIX(0) : crc,
+        crc_update,
     };
 
-    crc = rb_thread_blocking_region((VALUE (*)(void *))utils_crc32_update, &args, RUBY_UBF_IO, NULL);
-
-    rb_str_unlocktmp(src);
-
-    return crc;
+    return rb_ensure(crc_calc_try, (VALUE)&args, rb_str_unlocktmp, src);
 }
 
 
+static VALUE
+crc32_update(struct crc_args *args)
+{
+    return UINT2NUM(lzma_crc32(args->ptr, args->len, NUM2UINT(args->crc)));
+}
 
-struct utils_crc64_args
+/*
+ * call-seq:
+ *  LZMA::Utils.crc32(string, crc = 0)
+ *
+ * liblzmaに含まれるlzma_crc32を呼び出します。
+ */
+static VALUE
+utils_crc32(int argc, VALUE argv[], VALUE self)
 {
-    const uint8_t *ptr;
-    size_t len;
-    uint64_t crc;
-};
+    return crc_calc(crc32_update, argc, argv);
+}
+
 
 static VALUE
-utils_crc64_update(struct utils_crc64_args *args)
+crc64_update(struct crc_args *args)
 {
-    return ULL2NUM(lzma_crc64(args->ptr, args->len, args->crc));
+    return ULL2NUM(lzma_crc64(args->ptr, args->len, NUM2ULL(args->crc)));
 }
 
 /*
@@ -961,23 +1189,7 @@ utils_crc64_update(struct utils_crc64_args *args)
 static VALUE
 utils_crc64(int argc, VALUE argv[], VALUE self)
 {
-    VALUE src, crc;
-    rb_scan_args(argc, argv, "11", &src, &crc);
-
-    StringValue(src);
-    rb_str_locktmp(src);
-
-    struct utils_crc64_args args = {
-        (const uint8_t *)RSTRING_PTR(src),
-        RSTRING_LEN(src),
-        NIL_P(crc) ? 0 : NUM2ULL(crc),
-    };
-
-    crc = rb_thread_blocking_region((VALUE (*)(void *))utils_crc64_update, &args, RUBY_UBF_IO, NULL);
-
-    rb_str_unlocktmp(src);
-
-    return crc;
+    return crc_calc(crc64_update, argc, argv);
 }
 
 
@@ -987,26 +1199,21 @@ static void
 setup_utils(void)
 {
     mUtils = rb_define_module_under(mLZMA, "Utils");
-    rb_include_module(mLZMA, mUtils);
-    rb_extend_object(mLZMA, mUtils);
 
-    // rb_define_module_functionを使わない理由は、rb_define_module_functionで定義すると
-    // インスタンスメソッドがprivateで定義されるため、その対策。
-
-    rb_extend_object(mUtils, mUtils);
+    rb_extend_object(mLZMA, mUtils);
+    rb_extend_object(mUtils, mUtils); // 自分に対してもモジュールメソッドを利用できるようにする
 
     rb_define_method(mUtils, "crc32", RUBY_METHOD_FUNC(utils_crc32), -1);
     rb_define_method(mUtils, "crc64", RUBY_METHOD_FUNC(utils_crc64), -1);
 }
 
-
-// SECTION: LZMA
+// SECTION: LibLZMA
 
 void
 Init_liblzma(void)
 {
-    symDICTSIZE     = ID2SYM(rb_intern("dict_size"));
-    symPRESETDICT   = ID2SYM(rb_intern("preset_dict"));
+    symDICTSIZE     = ID2SYM(rb_intern("dictsize"));
+    symDICT         = ID2SYM(rb_intern("dict"));
     symLC           = ID2SYM(rb_intern("lc"));
     symLP           = ID2SYM(rb_intern("lp"));
     symPB           = ID2SYM(rb_intern("pb"));
@@ -1016,12 +1223,15 @@ Init_liblzma(void)
     symDEPTH        = ID2SYM(rb_intern("depth"));
     symCHECK        = ID2SYM(rb_intern("check"));
 
-    mLZMA = rb_define_module("LZMA");
+    IDdictpreset = rb_intern_const("liblzma.dict_preset");
+
+
+    mLZMA = rb_define_module("LibLZMA");
 
     setup_utils();
     setup_constants();
     setup_exceptions();
     setup_filter();
     setup_stream();
-    setup_index();
+//    setup_index();
 }

data/lib/liblzma.rb

@@ -1,131 +1,222 @@
 #vim: set fileencoding:utf-8
 
-require_relative "liblzma.so"
+ver = RbConfig::CONFIG["ruby_version"]
+lib = File.join(File.dirname(__FILE__), ver, "liblzma.so")
+if File.file?(lib)
+  require_relative File.join(ver, "liblzma.so")
+else
+  require_relative "liblzma.so"
+end
 
-module LZMA
-    module_function
-    def encode(data, *args)
-        s = Stream.encoder(Filter.lzma2(*args))
-        s.update(data, LZMA::FINISH)
-    end
 
-    module_function
-    def decode(data, *args)
-        s = Stream.auto_decoder(*args)
-        s.update(data, LZMA::FINISH)
+#--
+# This comment is avoid the problem that is recognized binary by rdoc
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#                                                                       #
+#++
+
+module LibLZMA
+  LZMA = self
+
+  # call-seq:
+  # LibLZMA.encode(data, ...) -> encoded_xz_data
+  #
+  # データを圧縮します。圧縮されたデータ列は、xz ファイルフォーマットとなるため、コマンドラインの xz などで伸張させることが可能です。
+  #
+  # [data]        圧縮元となるデータを String インスタンスで渡します。liblzma はエンコーディング情報を無視し、そのままのバイト列をバイナリデータと見立て処理を行います。
+  #
+  # [options]     LZMA::Filter::LZMA2.new に渡される可変引数です。詳細は LZMA::Filter::LZMA2.new を見てください。
+  #
+  # [RETURN]      xz データストリームとしての String インスタンスです。
+  #
+  # [EXCEPTIONS]  (NO DOCUMENT)
+  module_function
+  def encode(data, *args)
+    s = Stream.encoder(Filter.lzma2(*args))
+    s.update(data, LZMA::FINISH)
+  ensure
+    s.finish rescue nil if s
+  end
+
+  # call-seq:
+  # LZMA.decode(encoded_data, ...) -> string
+  #
+  # 圧縮されたデータを伸張します。
+  #
+  # [encoded_data] 圧縮されたデータを与えます。圧縮されたデータの形式は、xz と lzma です。これらはあらかじめ区別する必要なく与えることが出来ます。
+  #
+  # [options]     LZMA::Filter::LZMA2.new に渡される可変引数です。詳細は LZMA::Filter::LZMA2.new を見てください。
+  #
+  # [RETURN]      xz データストリームとしての String インスタンスです。
+  #
+  # [EXCEPTIONS]  (NO DOCUMENT)
+  module_function
+  def decode(data, *args)
+    s = Stream.auto_decoder(*args)
+    s.update(data, LZMA::FINISH)
+  ensure
+    s.finish rescue nil if s
+  end
+
+  # call-seq:
+  # LZMA.raw_encode(data, ...) -> encoded_data
+  #
+  # データを圧縮します。圧縮されたデータ列は生の lzma1/lzma2 のデータ列であるため、伸張する際に適切なフィルタを与える必要があります。
+  #
+  # xz ファイルフォーマットヘッダや整合値を持たないため、これらが不要な場合は有用かもしれません。
+  #
+  # [data]        圧縮元となるデータを String インスタンスで渡します。liblzma はエンコーディング情報を無視し、そのままのバイト列をバイナリデータと見立てて処理を行います。
+  #
+  # [options]     LZMA::Filter のインスタンスを与えます。
+  #
+  # [RETURN]      生の lzma1/lzma2 のデータ列となる String インスタンスです。
+  #
+  # [EXCEPTIONS]  (NO DOCUMENT)
+  module_function
+  def raw_encode(data, *args)
+    s = Stream.raw_encoder(*args)
+    s.update(data, LZMA::FINISH)
+  ensure
+    s.finish rescue nil if s
+  end
+
+  # call-seq:
+  # LZMA.raw_decode(encoded_data, ...) -> decoded_data
+  #
+  # 圧縮されたデータを伸張します。圧縮した際に用いたフィルタをそのままの順番・数で与える必要があります。
+  #
+  # [data]        圧縮された生の lzma1/lzma2 の String インスタンスを渡します。liblzma はエンコーディング情報を無視し、そのままのバイト列をバイナリデータと見立てて処理を行います。
+  #
+  # [options]     LZMA::Filter のインスタンスを与えます。
+  #
+  # [RETURN]      伸張されたデータ列となる String インスタンスです。
+  #
+  # [EXCEPTIONS]  (NO DOCUMENT)
+  module_function
+  def raw_decode(data, *args)
+    s = Stream.raw_decoder(*args)
+    s.update(data, LZMA::FINISH)
+  ensure
+    s.finish rescue nil if s
+  end
+
+  class Stream
+    def self.encoder(*args)
+      Encoder.new(*args)
     end
 
-    module_function
-    def raw_encode(data, *args)
-        s = Stream.raw_encoder(*args)
-        s.update(data, LZMA::FINISH)
+    def self.decoder(*args)
+      Decoder.new(*args)
     end
 
-    module_function
-    def raw_decode(data, *args)
-        s = Stream.raw_decoder(*args)
-        s.update(data, LZMA::FINISH)
+    def self.auto_decoder(*args)
+      AutoDecoder.new(*args)
     end
 
-    class Stream
-        def self.encoder(*args)
-            Encoder.new(*args)
-        end
-
-        def self.decoder(*args)
-            Decoder.new(*args)
-        end
-
-        def self.auto_decoder(*args)
-            AutoDecoder.new(*args)
-        end
-
-        def self.raw_encoder(*args)
-            RawEncoder.new(*args)
-        end
+    def self.raw_encoder(*args)
+      RawEncoder.new(*args)
+    end
 
-        def self.raw_decoder(*args)
-            RawDecoder.new(*args)
-        end
+    def self.raw_decoder(*args)
+      RawDecoder.new(*args)
     end
+  end
 
-    module Utils
-        class CRC32 < Struct.new(:state, :init)
-            def initialize(state = 0)
-                state = state.to_i
-                super(state, state)
-            end
+  module Utils
+    # CRC32 を Digest のように生成できるようになります。
+    class CRC32 < Struct.new(:state, :init)
+      def initialize(state = 0)
+        state = state.to_i
+        super(state, state)
+      end
 
-            def update(data)
-                self.state = Utils.crc32(data, state)
-                self
-            end
+      # call-seq:
+      # LZMA::Utils::CRC32#update(data) -> self
+      def update(data)
+        self.state = Utils.crc32(data, state)
+        self
+      end
 
-            alias << update
+      alias << update
 
-            def finish
-                self
-            end
+      def finish
+        self
+      end
 
-            def reset
-                self.state = init
-                self
-            end
+      def reset
+        self.state = init
+        self
+      end
 
-            def digest
-                [state].pack("N")
-            end
+      def digest
+        [state].pack("N")
+      end
 
-            def hexdigest
-                "%08x" % state
-            end
+      def hexdigest
+        "%08x" % state
+      end
 
-            alias to_s hexdigest
+      alias to_s hexdigest
 
-            def to_str
-                "CRC32 <#{hexdigest}>"
-            end
+      def to_str
+        "CRC32 <#{hexdigest}>"
+      end
 
-            alias inspect to_str
-        end
+      alias inspect to_str
+    end
 
-        class CRC64 < Struct.new(:state, :init)
-            def initialize(state = 0)
-                state = state.to_i
-                super(state, state)
-            end
+    # CRC64 を Digest のように生成できるようになります。
+    class CRC64 < Struct.new(:state, :init)
+      def initialize(state = 0)
+        state = state.to_i
+        super(state, state)
+      end
 
-            def update(data)
-                self.state = Utils.crc64(data, state)
-                self
-            end
+      # call-seq:
+      # LZMA::Utils::CRC64#update(data) -> self
+      def update(data)
+        self.state = Utils.crc64(data, state)
+        self
+      end
 
-            alias << update
+      alias << update
 
-            def finish
-                self
-            end
+      def finish
+        self
+      end
 
-            def reset
-                self.state = init
-                self
-            end
+      def reset
+        self.state = init
+        self
+      end
 
-            def digest
-                [state].pack("N")
-            end
+      def digest
+        [state].pack("Q>")
+      end
 
-            def hexdigest
-                "%016x" % state
-            end
+      def hexdigest
+        "%016x" % state
+      end
 
-            alias to_s hexdigest
+      alias to_s hexdigest
 
-            def to_str
-                "CRC64 <#{hexdigest}>"
-            end
+      def to_str
+        "CRC64 <#{hexdigest}>"
+      end
 
-            alias inspect to_str
-        end
+      alias inspect to_str
     end
+  end
 end
+
+LZMA = LibLZMA unless Object.const_defined?(:LZMA)

data/samples/01-easy_using.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 #vim: set fileencoding:utf-8
 
-# このrubyスクリプトはliblzmaの利用手引きを兼ねたサンプルスクリプトです。
+# このrubyスクリプトはliblzma for Rubyの利用手引きを兼ねたサンプルスクリプトです。
 
 
 # rubyでliblzmaの機能を利用するのに必要なのは、次の一文のみです

data/samples/02-streaming.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 #vim: set fileencoding:utf-8
 
-# このrubyスクリプトはruby-lzmaの利用手引きを兼ねたサンプルスクリプトです。
+# この ruby スクリプトは liblzma for Ruby の利用手引きを兼ねたサンプルスクリプトです。
 
 
 # 01-* ではデータの全てを用意してから処理を行う方法を提示しますた。

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liblzma
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-31 00:00:00.000000000 Z
+date: 2013-02-21 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: dearblue@users.sourceforge.jp
@@ -28,7 +28,12 @@ homepage:
 licenses:
 - 2-clause BSD License
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- -eUTF-8
+- -mREADME.txt
+- README.txt
+- ext/liblzma.c
+- lib/liblzma.rb
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -45,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.16
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: ruby bindings for liblzma that is included in the xz utilities