extlzma 0.4-x86-mingw32

data/ext/consts.c

@@ -0,0 +1,68 @@
+
+#include "extlzma.h"
+
+// SECTION: LZMA::Constants
+
+static VALUE mConstants;
+
+void
+extlzma_init_Constants(void)
+{
+    mConstants = rb_define_module_under(extlzma_mLZMA, "Constants");
+    rb_include_module(extlzma_mLZMA, mConstants);
+
+    // TODO: マクロを展開した状態で記述する。
+    // TODO: 目的は rdoc や yard で文書化できるようにするため。
+
+#define DEFINE_CONSTANT(NAME, VALUE)                       \
+    {                                                      \
+        rb_define_const(mConstants, #NAME, VALUE);         \
+        rb_define_const(mConstants, "LZMA_" #NAME, VALUE); \
+    }                                                      \
+
+    DEFINE_CONSTANT(NICE_DEFAULT,       SIZET2NUM(64));
+    DEFINE_CONSTANT(DEPTH_DEFAULT,      SIZET2NUM(0));
+
+    DEFINE_CONSTANT(PRESET_DEFAULT,     UINT2NUM(LZMA_PRESET_DEFAULT));
+    DEFINE_CONSTANT(PRESET_LEVEL_MASK,  UINT2NUM(LZMA_PRESET_LEVEL_MASK));
+    DEFINE_CONSTANT(PRESET_EXTREME,     UINT2NUM(LZMA_PRESET_EXTREME));
+    DEFINE_CONSTANT(DICT_SIZE_MIN,      UINT2NUM(LZMA_DICT_SIZE_MIN));
+    DEFINE_CONSTANT(DICT_SIZE_DEFAULT,  UINT2NUM(LZMA_DICT_SIZE_DEFAULT));
+    DEFINE_CONSTANT(LCLP_MIN,           UINT2NUM(LZMA_LCLP_MIN));
+    DEFINE_CONSTANT(LCLP_MAX,           UINT2NUM(LZMA_LCLP_MAX));
+    DEFINE_CONSTANT(LC_DEFAULT,         UINT2NUM(LZMA_LC_DEFAULT));
+    DEFINE_CONSTANT(LP_DEFAULT,         UINT2NUM(LZMA_LP_DEFAULT));
+    DEFINE_CONSTANT(PB_MIN,             UINT2NUM(LZMA_PB_MIN));
+    DEFINE_CONSTANT(PB_MAX,             UINT2NUM(LZMA_PB_MAX));
+    DEFINE_CONSTANT(PB_DEFAULT,         UINT2NUM(LZMA_PB_DEFAULT));
+    DEFINE_CONSTANT(MODE_FAST,          UINT2NUM(LZMA_MODE_FAST));
+    DEFINE_CONSTANT(MODE_NORMAL,        UINT2NUM(LZMA_MODE_NORMAL));
+    DEFINE_CONSTANT(MF_HC3,             UINT2NUM(LZMA_MF_HC3));
+    DEFINE_CONSTANT(MF_HC4,             UINT2NUM(LZMA_MF_HC4));
+    DEFINE_CONSTANT(MF_BT2,             UINT2NUM(LZMA_MF_BT2));
+    DEFINE_CONSTANT(MF_BT3,             UINT2NUM(LZMA_MF_BT3));
+    DEFINE_CONSTANT(MF_BT4,             UINT2NUM(LZMA_MF_BT4));
+
+    DEFINE_CONSTANT(CHECK_NONE,         UINT2NUM(LZMA_CHECK_NONE));
+    DEFINE_CONSTANT(CHECK_CRC32,        UINT2NUM(LZMA_CHECK_CRC32));
+    DEFINE_CONSTANT(CHECK_CRC64,        UINT2NUM(LZMA_CHECK_CRC64));
+    DEFINE_CONSTANT(CHECK_SHA256,       UINT2NUM(LZMA_CHECK_SHA256));
+
+    DEFINE_CONSTANT(RUN,                UINT2NUM(LZMA_RUN));
+    DEFINE_CONSTANT(FULL_FLUSH,         UINT2NUM(LZMA_FULL_FLUSH));
+    DEFINE_CONSTANT(SYNC_FLUSH,         UINT2NUM(LZMA_SYNC_FLUSH));
+    DEFINE_CONSTANT(FINISH,             UINT2NUM(LZMA_FINISH));
+
+    DEFINE_CONSTANT(OK,                 UINT2NUM(LZMA_OK));
+    DEFINE_CONSTANT(STREAM_END,         UINT2NUM(LZMA_STREAM_END));
+    DEFINE_CONSTANT(NO_CHECK,           UINT2NUM(LZMA_NO_CHECK));
+    DEFINE_CONSTANT(UNSUPPORTED_CHECK,  UINT2NUM(LZMA_UNSUPPORTED_CHECK));
+    DEFINE_CONSTANT(GET_CHECK,          UINT2NUM(LZMA_GET_CHECK));
+    DEFINE_CONSTANT(MEM_ERROR,          UINT2NUM(LZMA_MEM_ERROR));
+    DEFINE_CONSTANT(MEMLIMIT_ERROR,     UINT2NUM(LZMA_MEMLIMIT_ERROR));
+    DEFINE_CONSTANT(FORMAT_ERROR,       UINT2NUM(LZMA_FORMAT_ERROR));
+    DEFINE_CONSTANT(OPTIONS_ERROR,      UINT2NUM(LZMA_OPTIONS_ERROR));
+    DEFINE_CONSTANT(DATA_ERROR,         UINT2NUM(LZMA_DATA_ERROR));
+    DEFINE_CONSTANT(BUF_ERROR,          UINT2NUM(LZMA_BUF_ERROR));
+    DEFINE_CONSTANT(PROG_ERROR,         UINT2NUM(LZMA_PROG_ERROR));
+}

data/ext/error.c

@@ -0,0 +1,77 @@
+
+#include "extlzma.h"
+
+// TODO: 例外を整理して数を減らす。
+
+VALUE extlzma_mExceptions;
+VALUE extlzma_eBasicException;
+VALUE extlzma_eStreamEnd;
+VALUE extlzma_eNoCheck;
+VALUE extlzma_eUnsupportedCheck;
+VALUE extlzma_eGetCheck;
+VALUE extlzma_eMemError;
+VALUE extlzma_eMemlimitError;
+VALUE extlzma_eFormatError;
+VALUE extlzma_eOptionsError;
+VALUE extlzma_eDataError;
+VALUE extlzma_eBufError;
+VALUE extlzma_eProgError;
+VALUE extlzma_eFilterTooLong;
+VALUE extlzma_eBadPreset;
+
+static inline VALUE
+lookup_exception(lzma_ret status)
+{
+    switch (status) {
+    case LZMA_OK:                return Qnil;
+    case LZMA_STREAM_END:        return extlzma_eStreamEnd;
+    case LZMA_NO_CHECK:          return extlzma_eNoCheck;
+    case LZMA_UNSUPPORTED_CHECK: return extlzma_eUnsupportedCheck;
+    case LZMA_GET_CHECK:         return extlzma_eGetCheck;
+    case LZMA_MEM_ERROR:         return extlzma_eMemError;
+    case LZMA_MEMLIMIT_ERROR:    return extlzma_eMemlimitError;
+    case LZMA_FORMAT_ERROR:      return extlzma_eFormatError;
+    case LZMA_OPTIONS_ERROR:     return extlzma_eOptionsError;
+    case LZMA_DATA_ERROR:        return extlzma_eDataError;
+    case LZMA_BUF_ERROR:         return extlzma_eBufError;
+    case LZMA_PROG_ERROR:        return extlzma_eProgError;
+    default:                     return rb_eRuntimeError;
+    }
+}
+
+VALUE
+extlzma_lookup_error(lzma_ret status)
+{
+    return lookup_exception(status);
+}
+
+void
+extlzma_init_Exceptions(void)
+{
+    extlzma_mExceptions = rb_define_module_under(extlzma_mLZMA, "Exceptions");
+    rb_include_module(extlzma_mLZMA, extlzma_mExceptions);
+
+    extlzma_eBasicException = rb_define_class_under(extlzma_mExceptions, "BasicException", rb_eStandardError);
+    rb_define_class_under(extlzma_mExceptions, "FilterTooLong", extlzma_eBasicException);
+    rb_define_class_under(extlzma_mExceptions, "BadPreset", extlzma_eBasicException);
+
+#define DEFINE_EXCEPTION(CLASS, STATUS)                                           \
+    {                                                                             \
+        extlzma_e ## CLASS =                                                      \
+            rb_define_class_under(extlzma_mExceptions,                            \
+                #CLASS, extlzma_eBasicException);                                 \
+        rb_define_const(extlzma_e ## CLASS, "STATUS", SIZET2NUM(STATUS));         \
+    }                                                                             \
+
+    DEFINE_EXCEPTION(StreamEnd,        LZMA_STREAM_END);
+    DEFINE_EXCEPTION(NoCheck,          LZMA_NO_CHECK);
+    DEFINE_EXCEPTION(UnsupportedCheck, LZMA_UNSUPPORTED_CHECK);
+    DEFINE_EXCEPTION(GetCheck,         LZMA_GET_CHECK);
+    DEFINE_EXCEPTION(MemError,         LZMA_MEM_ERROR);
+    DEFINE_EXCEPTION(MemlimitError,    LZMA_MEMLIMIT_ERROR);
+    DEFINE_EXCEPTION(FormatError,      LZMA_FORMAT_ERROR);
+    DEFINE_EXCEPTION(OptionsError,     LZMA_OPTIONS_ERROR);
+    DEFINE_EXCEPTION(DataError,        LZMA_DATA_ERROR);
+    DEFINE_EXCEPTION(BufError,         LZMA_BUF_ERROR);
+    DEFINE_EXCEPTION(ProgError,        LZMA_PROG_ERROR);
+}

data/ext/extconf.rb

@@ -0,0 +1,27 @@
+#!ruby
+
+require "mkmf"
+
+needlist = []
+
+have_header "lzma.h" or needlist << "lzma.h"
+have_library "lzma" or needlist << "liblzma.a"
+
+unless needlist.empty?
+  abort "#$0: dependency files are not found (#{needlist.join(" ")})."
+end
+
+staticlink = arg_config("--liblzma-static-link", false)
+
+if staticlink
+  # 静的ライブラリリンクを優先する
+  $libs = ["-Wl,-dn,-llzma", "-Wl,-llzma", $libs].join(" ")
+end
+
+if RbConfig::CONFIG["arch"] =~ /mingw/
+  $LDFLAGS << " -static-libgcc " if try_link "void main(void){}", " -static-libgcc "
+end
+
+$LDFLAGS << " -Wl,-Bsymbolic " if try_link "void main(void){}", " -Wl,-Bsymbolic "
+
+create_makefile "extlzma"

data/ext/extlzma.c

@@ -0,0 +1,97 @@
+/*
+ * liblzma.c -
+ * - Author:    dearblue <dearblue@users.osdn.me>
+ * - Copyright: Copyright (c) 2010 dearblue
+ * - License:   Distributed under the 2-clause BSD License
+ */
+
+#include "extlzma.h"
+
+VALUE extlzma_mLZMA;
+
+ID extlzma_id_dictsize;
+ID extlzma_id_predict;
+ID extlzma_id_lc;
+ID extlzma_id_lp;
+ID extlzma_id_pb;
+ID extlzma_id_mode;
+ID extlzma_id_nice;
+ID extlzma_id_mf;
+ID extlzma_id_depth;
+ID extlzma_id_check;
+ID extlzma_id_none;
+ID extlzma_id_crc32;
+ID extlzma_id_crc64;
+ID extlzma_id_sha256;
+
+static VALUE
+libver_major(VALUE obj)
+{
+    return INT2FIX(LZMA_VERSION_MAJOR);
+}
+
+static VALUE
+libver_minor(VALUE obj)
+{
+    return INT2FIX(LZMA_VERSION_MINOR);
+}
+
+static VALUE
+libver_patch(VALUE obj)
+{
+    return INT2FIX(LZMA_VERSION_PATCH);
+}
+
+static VALUE
+libver_to_s(VALUE obj)
+{
+    return rb_str_new_cstr(LZMA_VERSION_STRING);
+}
+
+
+static void
+extlzma_init_LIBVER(void)
+{
+    VALUE vers[] = {
+        INT2FIX(LZMA_VERSION_MAJOR),
+        INT2FIX(LZMA_VERSION_MINOR),
+        INT2FIX(LZMA_VERSION_PATCH)
+    };
+
+    VALUE libver = rb_ary_new4(ELEMENTOF(vers), vers);
+    rb_define_singleton_method(libver, "major", RUBY_METHOD_FUNC(libver_major), 0);
+    rb_define_singleton_method(libver, "minor", RUBY_METHOD_FUNC(libver_minor), 0);
+    rb_define_singleton_method(libver, "patch", RUBY_METHOD_FUNC(libver_patch), 0);
+    rb_define_singleton_method(libver, "to_s", RUBY_METHOD_FUNC(libver_to_s), 0);
+    rb_define_const(extlzma_mLZMA, "LIBRARY_VERSION", rb_ary_freeze(libver));
+}
+
+void
+Init_extlzma(void)
+{
+    extlzma_id_dictsize = rb_intern("dictsize");
+    extlzma_id_predict  = rb_intern("predict");
+    extlzma_id_lc       = rb_intern("lc");
+    extlzma_id_lp       = rb_intern("lp");
+    extlzma_id_pb       = rb_intern("pb");
+    extlzma_id_mode     = rb_intern("mode");
+    extlzma_id_nice     = rb_intern("nice");
+    extlzma_id_mf       = rb_intern("mf");
+    extlzma_id_depth    = rb_intern("depth");
+    extlzma_id_check    = rb_intern("check");
+    extlzma_id_none     = rb_intern("none");
+    extlzma_id_crc32    = rb_intern("crc32");
+    extlzma_id_crc64    = rb_intern("crc64");
+    extlzma_id_sha256   = rb_intern("sha256");
+
+    extlzma_mLZMA = rb_define_module("LZMA");
+    rb_define_const(extlzma_mLZMA, "LZMA", extlzma_mLZMA);
+
+    extlzma_init_Utils();
+    extlzma_init_Constants();
+    extlzma_init_Exceptions();
+    extlzma_init_Filter();
+    extlzma_init_Stream();
+    extlzma_init_Index();
+    extlzma_init_LIBVER();
+}

data/ext/extlzma.h

@@ -0,0 +1,177 @@
+#ifndef EXTLZMA_H
+#define EXTLZMA_H 1
+
+#include <stdarg.h>
+#include <lzma.h>
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/intern.h>
+
+#define LOG { fprintf(stderr, "%s:%d:%s\n", __FILE__, __LINE__, __func__); }
+
+#define LOGF(FORMAT, ...)                                           \
+    {                                                               \
+        fprintf(stderr, "%s:%d:%s: " FORMAT "\n",                   \
+                __FILE__, __LINE__, __func__, ## __VA_ARGS__);      \
+    }                                                               \
+
+#define ELEMENTOF(VECT) (sizeof(VECT) / sizeof((VECT)[0]))
+
+#define AUX_FUNCALL(RECV, METHOD, ...)                  \
+    ({                                                  \
+        VALUE args__aux_funcall__[] = { __VA_ARGS__ };  \
+        rb_funcall2((RECV), (METHOD),                   \
+                ELEMENTOF(args__aux_funcall__),         \
+                args__aux_funcall__);                   \
+    })                                                  \
+
+extern VALUE extlzma_mLZMA;
+extern VALUE extlzma_cFilter;
+extern VALUE extlzma_cStream;
+extern VALUE extlzma_mExceptions;
+
+extern VALUE extlzma_eBasicException;
+extern VALUE extlzma_eStreamEnd;
+extern VALUE extlzma_eNoCheck;
+extern VALUE extlzma_eUnsupportedCheck;
+extern VALUE extlzma_eGetCheck;
+extern VALUE extlzma_eMemError;
+extern VALUE extlzma_eMemlimitError;
+extern VALUE extlzma_eFormatError;
+extern VALUE extlzma_eOptionsError;
+extern VALUE extlzma_eDataError;
+extern VALUE extlzma_eBufError;
+extern VALUE extlzma_eProgError;
+extern VALUE extlzma_eFilterTooLong;
+extern VALUE extlzma_eBadPreset;
+
+extern ID extlzma_id_dictsize;
+extern ID extlzma_id_predict;
+extern ID extlzma_id_lc;
+extern ID extlzma_id_lp;
+extern ID extlzma_id_pb;
+extern ID extlzma_id_mode;
+extern ID extlzma_id_nice;
+extern ID extlzma_id_mf;
+extern ID extlzma_id_depth;
+extern ID extlzma_id_check;
+extern ID extlzma_id_none;
+extern ID extlzma_id_crc32;
+extern ID extlzma_id_crc64;
+extern ID extlzma_id_sha256;
+
+extern void extlzma_init_Stream(void);
+extern void extlzma_init_Utils(void);
+extern void extlzma_init_Constants(void);
+extern void extlzma_init_Exceptions(void);
+extern void extlzma_init_Filter(void);
+extern void extlzma_init_Index(void);
+extern VALUE extlzma_lookup_error(lzma_ret status);
+
+static inline int
+aux_lzma_isfailed(lzma_ret status)
+{
+    return status != 0;
+}
+
+static inline void
+aux_lzma_test(lzma_ret status)
+{
+    if (aux_lzma_isfailed(status)) {
+        VALUE exc = extlzma_lookup_error(status);
+        exc = rb_exc_new2(exc, "failed lzma processing");
+        rb_exc_raise(exc);
+    }
+}
+
+#define AUX_LZMA_TEST(STATUS) aux_lzma_test((STATUS))
+
+static inline void *
+checkref(VALUE obj, void *p)
+{
+    if (!p) {
+        rb_raise(rb_eArgError,
+                 "not initialized yet - #<%s:%p>",
+                 rb_obj_classname(obj), (void *)obj);
+    }
+
+    return p;
+}
+
+static inline void *
+check_notref(VALUE obj, void *p)
+{
+    if (p) {
+        rb_raise(rb_eArgError,
+                 "already initialized - #<%s:%p>",
+                 rb_obj_classname(obj), (void *)obj);
+    }
+
+    return p;
+}
+
+static inline void *
+getrefp(VALUE obj)
+{
+    void *p;
+    Data_Get_Struct(obj, void, p);
+    return p;
+}
+
+static inline void *
+getref(VALUE obj)
+{
+    return checkref(obj, getrefp(obj));
+}
+
+static inline lzma_filter *
+getfilterp(VALUE obj)
+{
+    return getrefp(obj);
+}
+
+static inline lzma_filter *
+extlzma_getfilter(VALUE obj)
+{
+    return getref(obj);
+}
+
+// rdoc に対して定義されているものと錯覚させるマクロ
+#define RDOCFAKE(...)
+
+#define EXTLZMA_NOT_REACHABLE                \
+    rb_bug("NOT REACHABLE HERE - %s:%d(%s)", \
+           __FILE__, __LINE__, __func__);    \
+
+
+static inline void *
+aux_thread_call_without_gvl_main(void *pp)
+{
+    va_list *p = (va_list *)pp;
+    void *(*func)(void *) = va_arg(*p, void *(*)(void *));
+    va_list *va2 = va_arg(*p, va_list *);
+    return func(va2);
+}
+
+static inline void *
+aux_thread_call_without_gvl_dummy(void *dummy, ...)
+{
+    va_list va;
+    va_start(va, dummy);
+    void *p = rb_thread_call_without_gvl(
+            aux_thread_call_without_gvl_main, &va, RUBY_UBF_PROCESS, 0);
+    va_end(va);
+    return p;
+}
+
+static inline void *
+aux_thread_call_without_gvl(void *(*func)(va_list *), ...)
+{
+    va_list va;
+    va_start(va, func);
+    void *p = aux_thread_call_without_gvl_dummy(0, func, &va);
+    va_end(va);
+    return p;
+}
+
+#endif /* EXTLZMA_H */