extlzma2 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7f84d15806e0cb31f8e0b59e2947b4f8de9bd471ba8943ad5e4cc664593169d3
+  data.tar.gz: 6750dc99dfb4b9213017cb47fde94e64b9876f2e289686825c29836fa632b539
+SHA512:
+  metadata.gz: 64e5f7d38cca11899c5940d2e27977c29fd6f644d4196a14f2a72719233938c582c374cd4a4e3182d32c745f06476ce53e68dbbb6a921dd0d799f9b192068a5c
+  data.tar.gz: 86a2001fc1452cde9c38efac27cb4345a09eac91ac0eaed8b4752502778de88359fcb80fd30a5cf4aa9e04044011883dc337a414dcc57380a92e633b1e9e440b

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec_status

@@ -0,0 +1,17 @@
+example_id                          | status | run_time        |
+----------------------------------- | ------ | --------------- |
+./spec/decode_args_spec.rb[1:1:1]   | passed | 0.00158 seconds |
+./spec/decode_args_spec.rb[1:2:1]   | passed | 0.0001 seconds  |
+./spec/decode_args_spec.rb[1:3:1]   | passed | 0.0001 seconds  |
+./spec/encode_args_spec.rb[1:1:1]   | passed | 0.00074 seconds |
+./spec/encode_args_spec.rb[1:2:1]   | passed | 0.0001 seconds  |
+./spec/encode_args_spec.rb[1:3:1]   | passed | 0.0001 seconds  |
+./spec/encode_args_spec.rb[1:4:1]   | passed | 0.00065 seconds |
+./spec/encode_args_spec.rb[1:5:1]   | passed | 0.0001 seconds  |
+./spec/encode_decode_spec.rb[1:1:1] | passed | 0.00174 seconds |
+./spec/encode_decode_spec.rb[1:2:1] | passed | 0.00014 seconds |
+./spec/encode_decode_spec.rb[1:3:1] | passed | 0.41257 seconds |
+./spec/encode_decode_spec.rb[1:4:1] | passed | 0.0002 seconds  |
+./spec/encode_decode_spec.rb[1:5:1] | passed | 0.41836 seconds |
+./spec/encode_decode_spec.rb[1:6:1] | passed | 0.00096 seconds |
+./spec/encode_decode_spec.rb[1:7:1] | passed | 3.92 seconds    |

data/.rubocop.yml

@@ -0,0 +1,42 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Metrics/AbcSize:
+  Max: 170
+
+Metrics/BlockLength:
+  Max: 250
+
+Metrics/ClassLength:
+  Max: 1000
+
+Metrics/CyclomaticComplexity:
+  Max: 70
+
+Metrics/MethodLength:
+  Max: 100
+
+Metrics/ModuleLength:
+  Max: 1000
+
+Metrics/ParameterLists:
+  Max: 50
+
+Metrics/PerceivedComplexity:
+  Max: 80
+
+Layout/SpaceInsideBlockBraces:
+  EnforcedStyle: no_space
+  SpaceBeforeBlockParameters: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/NumericPredicate:
+  EnforcedStyle: comparison
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  EnforcedStyle: use_perl_names

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in extlzma2.gemspec
+gemspec
+
+gem 'rake'
+gem 'rake-compiler'
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    extlzma2 (2.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    rake (13.0.6)
+    rake-compiler (1.2.0)
+      rake
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  extlzma2!
+  rake
+  rake-compiler
+  rspec
+
+BUNDLED WITH
+   2.4.0.dev

data/LICENSE

@@ -0,0 +1,26 @@
+extlzma license (2-clause BSD License)
+
+Copyright (c) 2011, dearblue. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,9 @@
+This is a Ruby-3.2-compatible fork of [extlzma](https://rubygems.org/gems/extlzma)
+
+# extlzma - lzma for Ruby
+
+A Ruby binding of liblzma.
+
+## License
+
+This gem is provided under the BSD 2-clause License.

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'rspec/core/rake_task'
+
+task build: :compile
+
+Rake::ExtensionTask.new('extlzma2') do |ext|
+  ext.lib_dir = 'lib/extlzma2'
+end
+
+task default: %i[clobber compile]
+
+RSpec::Core::RakeTask.new(:spec)

data/ext/extlzma2/consts.c

@@ -0,0 +1,66 @@
+#include "extlzma2.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/extlzma2/error.c

@@ -0,0 +1,87 @@
+#include "extlzma2.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/extlzma2/extconf.rb

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

data/ext/extlzma2/extlzma2.c

@@ -0,0 +1,89 @@
+/*
+ * liblzma.c -
+ * - Author:    dearblue <dearblue@users.osdn.me>
+ * - Copyright: Copyright (c) 2010 dearblue
+ * - License:   Distributed under the 2-clause BSD License
+ */
+
+#include "extlzma2.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_extlzma2(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/extlzma2/extlzma2.h

@@ -0,0 +1,171 @@
+#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 */