extzstd 0.1 → 0.3.2

data/ext/depend

@@ -0,0 +1,2 @@
+extzstd.o: extzstd.c extzstd.h
+extzstd_stream.o: extzstd_stream.c extzstd.h extzstd_nogvls.h

data/ext/extconf.rb

@@ -4,10 +4,10 @@ require "mkmf"
 
 $INCFLAGS = %w(
   -I$(srcdir)/../contrib
-  -I$(srcdir)/../contrib/zstd
-  -I$(srcdir)/../contrib/zstd/common
-  -I$(srcdir)/../contrib/zstd/dictBuilder
-  -I$(srcdir)/../contrib/zstd/legacy
+  -I$(srcdir)/../contrib/zstd/lib
+  -I$(srcdir)/../contrib/zstd/lib/common
+  -I$(srcdir)/../contrib/zstd/lib/dictBuilder
+  -I$(srcdir)/../contrib/zstd/lib/legacy
 ).join(" ") + " #$INCFLAGS"
 
 #dir = File.dirname(__FILE__).gsub(/[\[\{\?\*]/, "[\\0]")
@@ -17,8 +17,17 @@ $INCFLAGS = %w(
 #$srcs = files
 #$VPATH.push "$(srcdir)/../contrib/zstd", "$(srcdir)/../contrib/zstd/legacy"
 
-if RbConfig::CONFIG["arch"] =~ /mingw/
-  $LDFLAGS << " -static-libgcc"
+if RbConfig::CONFIG["arch"] =~ /mingw/i
+  $LDFLAGS << " -static-libgcc" if try_ldflags("-static-libgcc")
+else
+  if try_compile(<<-"VISIBILITY")
+__attribute__ ((visibility("hidden"))) int conftest(void) { return 0; }
+  VISIBILITY
+    if try_cflags("-fvisibility=hidden")
+      $CFLAGS << " -fvisibility=hidden"
+      $defs << %('-DRBEXT_API=__attribute__ ((visibility("default")))')
+    end
+  end
 end
 
 create_makefile File.join(RUBY_VERSION.slice(/\d+\.\d+/), "extzstd")

data/ext/extzstd.c

@@ -1,38 +1,17 @@
 #include "extzstd.h"
-#include <zstd/common/mem.h>
+#include <zstd/lib/common/mem.h>
 #include <zstd_errors.h>
 #include <zdict.h>
 
-static void
-aux_string_pointer(VALUE str, const char **ptr, size_t *size)
-{
-    rb_check_type(str, RUBY_T_STRING);
-    RSTRING_GETMEM(str, *ptr, *size);
-}
-
-static void
-aux_string_pointer_with_nil(VALUE str, const char **ptr, size_t *size)
-{
-    if (NIL_P(str)) {
-        *ptr = NULL;
-        *size = 0;
-    } else {
-        aux_string_pointer(str, ptr, size);
-    }
-}
-
-static void
-aux_string_expand_pointer(VALUE str, char **ptr, size_t size)
-{
-    rb_check_type(str, RUBY_T_STRING);
-    rb_str_modify(str);
-    rb_str_set_len(str, 0);
-    rb_str_modify_expand(str, size);
-    *ptr = RSTRING_PTR(str);
-}
+#ifndef RB_EXT_RACTOR_SAFE
+# define RB_EXT_RACTOR_SAFE(FEATURE) ((void)(FEATURE))
+#endif
 
 VALUE extzstd_mZstd;
 
+static ID id_initialize;
+static ID id_error_code;
+
 /*
  * constant Zstd::LIBRARY_VERSION
  */
@@ -83,25 +62,6 @@ init_libver(void)
 VALUE extzstd_mExceptions;
 
 VALUE extzstd_eError;
-VALUE extzstd_eError;
-VALUE extzstd_eGenericError;
-VALUE extzstd_ePrefixUnknownError;
-VALUE extzstd_eFrameParameterUnsupportedError;
-VALUE extzstd_eFrameParameterUnsupportedBy32bitsError;
-VALUE extzstd_eCompressionParameterUnsupportedError;
-VALUE extzstd_eInitMissingError;
-VALUE extzstd_eMemoryAllocationError;
-VALUE extzstd_eStageWrongError;
-VALUE extzstd_eDstSizeTooSmallError;
-VALUE extzstd_eSrcSizeWrongError;
-VALUE extzstd_eCorruptionDetectedError;
-VALUE extzstd_eChecksumWrongError;
-VALUE extzstd_eTableLogTooLargeError;
-VALUE extzstd_eMaxSymbolValueTooLargeError;
-VALUE extzstd_eMaxSymbolValueTooSmallError;
-VALUE extzstd_eDictionaryCorruptedError;
-VALUE extzstd_eDictionaryWrongError;
-
 
 void
 extzstd_check_error(ssize_t errcode)
@@ -118,16 +78,20 @@ extzstd_error(ssize_t errcode)
 }
 
 VALUE
-extzstd_make_errorf(VALUE exc, const char *fmt, ...)
+extzstd_make_errorf(ssize_t errcode, const char *fmt, ...)
 {
+    VALUE e;
+
     if (fmt && strlen(fmt) > 0) {
+        VALUE args[] = { SSIZET2NUM(errcode), Qnil };
         va_list va;
         va_start(va, fmt);
-        VALUE mesg = rb_vsprintf(fmt, va);
+        args[1] = rb_vsprintf(fmt, va);
         va_end(va);
-        return rb_exc_new3(exc, mesg);
+        return rb_class_new_instance(2, args, extzstd_eError);
     } else {
-        return rb_exc_new2(exc, "");
+        VALUE args[] = { SSIZET2NUM(errcode) };
+        return rb_class_new_instance(1, args, extzstd_eError);
     }
 }
 
@@ -136,33 +100,34 @@ extzstd_make_error(ssize_t errcode)
 {
     if (!ZSTD_isError(errcode)) { return Qnil; }
 
-#define CASE_ERROR(zstderr, extzstderr, ...)                            \
-    case zstderr: return extzstd_make_errorf(extzstderr, __VA_ARGS__);  \
-
-    switch (-errcode) {
-    CASE_ERROR(ZSTD_error_GENERIC, extzstd_eGenericError, NULL);
-    CASE_ERROR(ZSTD_error_prefix_unknown, extzstd_ePrefixUnknownError, NULL);
-    CASE_ERROR(ZSTD_error_frameParameter_unsupported, extzstd_eFrameParameterUnsupportedError, NULL);
-    CASE_ERROR(ZSTD_error_frameParameter_unsupportedBy32bits, extzstd_eFrameParameterUnsupportedBy32bitsError, NULL);
-    CASE_ERROR(ZSTD_error_compressionParameter_unsupported, extzstd_eCompressionParameterUnsupportedError, NULL);
-    CASE_ERROR(ZSTD_error_init_missing, extzstd_eInitMissingError, NULL);
-    CASE_ERROR(ZSTD_error_memory_allocation, extzstd_eMemoryAllocationError, NULL);
-    CASE_ERROR(ZSTD_error_stage_wrong, extzstd_eStageWrongError, NULL);
-    CASE_ERROR(ZSTD_error_dstSize_tooSmall, extzstd_eDstSizeTooSmallError, NULL);
-    CASE_ERROR(ZSTD_error_srcSize_wrong, extzstd_eSrcSizeWrongError, NULL);
-    CASE_ERROR(ZSTD_error_corruption_detected, extzstd_eCorruptionDetectedError, NULL);
-    CASE_ERROR(ZSTD_error_checksum_wrong, extzstd_eChecksumWrongError, NULL);
-    CASE_ERROR(ZSTD_error_tableLog_tooLarge, extzstd_eTableLogTooLargeError, NULL);
-    CASE_ERROR(ZSTD_error_maxSymbolValue_tooLarge, extzstd_eMaxSymbolValueTooLargeError, NULL);
-    CASE_ERROR(ZSTD_error_maxSymbolValue_tooSmall, extzstd_eMaxSymbolValueTooSmallError, NULL);
-    CASE_ERROR(ZSTD_error_dictionary_corrupted, extzstd_eDictionaryCorruptedError, NULL);
-    CASE_ERROR(ZSTD_error_dictionary_wrong, extzstd_eDictionaryWrongError, NULL);
-    default:
-        return extzstd_make_errorf(extzstd_eError,
-                "unknown zstd error code (%d)", errcode);
-    }
+    return extzstd_make_errorf(ZSTD_getErrorCode(errcode), NULL);
+}
+
+static VALUE
+err_initialize(int argc, VALUE argv[], VALUE err)
+{
+    VALUE errcode;
+
+    rb_scan_args(argc, argv, "1*", &errcode, NULL);
+    rb_call_super(argc - 1, argv + 1);
+    rb_ivar_set(err, id_error_code, errcode);
+
+    return err;
+}
 
-#undef CASE_ERROR
+static VALUE
+err_errcode(VALUE err)
+{
+    return rb_ivar_get(err, id_error_code);
+}
+
+static VALUE
+err_to_s(VALUE err)
+{
+    ZSTD_ErrorCode code = (ZSTD_ErrorCode)NUM2SSIZET(rb_ivar_get(err, id_error_code));
+    VALUE mesg = rb_call_super(0, NULL);
+    VALUE mesg2 = rb_sprintf(" - %s (errcode: %d)", ZSTD_getErrorString(code), (int)code);
+    return rb_str_plus(mesg, mesg2);
 }
 
 static void
@@ -172,57 +137,10 @@ init_error(void)
 
     extzstd_eError = rb_define_class_under(extzstd_mZstd, "Error", rb_eRuntimeError);
     rb_include_module(extzstd_eError, extzstd_mExceptions);
-
-    extzstd_eGenericError = rb_define_class_under(extzstd_mZstd, "GenericError", rb_eRuntimeError);
-    rb_include_module(extzstd_eGenericError, extzstd_mExceptions);
-
-    extzstd_ePrefixUnknownError = rb_define_class_under(extzstd_mZstd, "PrefixUnknownError", rb_eArgError);
-    rb_include_module(extzstd_ePrefixUnknownError, extzstd_mExceptions);
-
-    extzstd_eFrameParameterUnsupportedError = rb_define_class_under(extzstd_mZstd, "FrameParameterUnsupportedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eFrameParameterUnsupportedError, extzstd_mExceptions);
-
-    extzstd_eFrameParameterUnsupportedBy32bitsError = rb_define_class_under(extzstd_mZstd, "FrameParameterUnsupportedBy32bitsImplementationError", rb_eRuntimeError);
-    rb_include_module(extzstd_eFrameParameterUnsupportedBy32bitsError, extzstd_mExceptions);
-
-    extzstd_eCompressionParameterUnsupportedError = rb_define_class_under(extzstd_mZstd, "CompressionParameterUnsupportedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eCompressionParameterUnsupportedError, extzstd_mExceptions);
-
-    extzstd_eInitMissingError = rb_define_class_under(extzstd_mZstd, "InitMissingError", rb_eRuntimeError);
-    rb_include_module(extzstd_eInitMissingError, extzstd_mExceptions);
-
-    extzstd_eMemoryAllocationError = rb_define_class_under(extzstd_mZstd, "MemoryAllocationError", aux_const_dig_str(rb_cObject, "Errno", "ENOMEM"));
-    rb_include_module(extzstd_eMemoryAllocationError, extzstd_mExceptions);
-
-    extzstd_eStageWrongError = rb_define_class_under(extzstd_mZstd, "StageWrongError", rb_eRuntimeError);
-    rb_include_module(extzstd_eStageWrongError, extzstd_mExceptions);
-
-    extzstd_eDstSizeTooSmallError = rb_define_class_under(extzstd_mZstd, "DstSizeTooSmallError", rb_eArgError);
-    rb_include_module(extzstd_eDstSizeTooSmallError, extzstd_mExceptions);
-
-    extzstd_eSrcSizeWrongError = rb_define_class_under(extzstd_mZstd, "SrcSizeWrongError", rb_eArgError);
-    rb_include_module(extzstd_eSrcSizeWrongError, extzstd_mExceptions);
-
-    extzstd_eCorruptionDetectedError = rb_define_class_under(extzstd_mZstd, "CorruptionDetectedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eCorruptionDetectedError, extzstd_mExceptions);
-
-    extzstd_eChecksumWrongError = rb_define_class_under(extzstd_mZstd, "ChecksumWrongError", rb_eRuntimeError);
-    rb_include_module(extzstd_eChecksumWrongError, extzstd_mExceptions);
-
-    extzstd_eTableLogTooLargeError = rb_define_class_under(extzstd_mZstd, "TableLogTooLargeError", rb_eArgError);
-    rb_include_module(extzstd_eTableLogTooLargeError, extzstd_mExceptions);
-
-    extzstd_eMaxSymbolValueTooLargeError = rb_define_class_under(extzstd_mZstd, "MaxSymbolValueTooLargeError", rb_eArgError);
-    rb_include_module(extzstd_eMaxSymbolValueTooLargeError, extzstd_mExceptions);
-
-    extzstd_eMaxSymbolValueTooSmallError = rb_define_class_under(extzstd_mZstd, "MaxSymbolValueTooSmallError", rb_eArgError);
-    rb_include_module(extzstd_eMaxSymbolValueTooSmallError, extzstd_mExceptions);
-
-    extzstd_eDictionaryCorruptedError = rb_define_class_under(extzstd_mZstd, "DictionaryCorruptedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eDictionaryCorruptedError, extzstd_mExceptions);
-
-    extzstd_eDictionaryWrongError = rb_define_class_under(extzstd_mZstd, "DictionaryWrongError", rb_eRuntimeError);
-    rb_include_module(extzstd_eDictionaryWrongError, extzstd_mExceptions);
+    rb_define_method(extzstd_eError, "initialize", err_initialize, -1);
+    rb_define_method(extzstd_eError, "error_code", err_errcode, 0);
+    rb_define_method(extzstd_eError, "to_s", err_to_s, 0);
+    rb_define_alias(extzstd_eError, "errcode", "error_code");
 }
 
 /*
@@ -245,6 +163,8 @@ init_constants(void)
     rb_define_const(mConstants, "ZSTD_LAZY2", INT2NUM(ZSTD_lazy2));
     rb_define_const(mConstants, "ZSTD_BTLAZY2", INT2NUM(ZSTD_btlazy2));
     rb_define_const(mConstants, "ZSTD_BTOPT", INT2NUM(ZSTD_btopt));
+    rb_define_const(mConstants, "ZSTD_BTULTRA", INT2NUM(ZSTD_btultra));
+    rb_define_const(mConstants, "ZSTD_BTULTRA2", INT2NUM(ZSTD_btultra2));
     rb_define_const(mConstants, "ZSTD_WINDOWLOG_MAX", INT2NUM(ZSTD_WINDOWLOG_MAX));
     rb_define_const(mConstants, "ZSTD_WINDOWLOG_MIN", INT2NUM(ZSTD_WINDOWLOG_MIN));
     rb_define_const(mConstants, "ZSTD_HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
@@ -254,10 +174,10 @@ init_constants(void)
     rb_define_const(mConstants, "ZSTD_HASHLOG3_MAX", INT2NUM(ZSTD_HASHLOG3_MAX));
     rb_define_const(mConstants, "ZSTD_SEARCHLOG_MAX", INT2NUM(ZSTD_SEARCHLOG_MAX));
     rb_define_const(mConstants, "ZSTD_SEARCHLOG_MIN", INT2NUM(ZSTD_SEARCHLOG_MIN));
-    rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
-    rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
-    rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
-    rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
+    //rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
+    //rb_define_const(mConstants, "ZSTD_SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
+    //rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
+    //rb_define_const(mConstants, "ZSTD_TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
 
     rb_define_const(mConstants, "FAST", INT2NUM(ZSTD_fast));
     rb_define_const(mConstants, "DFAST", INT2NUM(ZSTD_dfast));
@@ -266,6 +186,8 @@ init_constants(void)
     rb_define_const(mConstants, "LAZY2", INT2NUM(ZSTD_lazy2));
     rb_define_const(mConstants, "BTLAZY2", INT2NUM(ZSTD_btlazy2));
     rb_define_const(mConstants, "BTOPT", INT2NUM(ZSTD_btopt));
+    rb_define_const(mConstants, "BTULTRA", INT2NUM(ZSTD_btultra));
+    rb_define_const(mConstants, "BTULTRA2", INT2NUM(ZSTD_btultra2));
     rb_define_const(mConstants, "WINDOWLOG_MAX", INT2NUM(ZSTD_WINDOWLOG_MAX));
     rb_define_const(mConstants, "WINDOWLOG_MIN", INT2NUM(ZSTD_WINDOWLOG_MIN));
     rb_define_const(mConstants, "HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
@@ -275,10 +197,10 @@ init_constants(void)
     rb_define_const(mConstants, "HASHLOG3_MAX", INT2NUM(ZSTD_HASHLOG3_MAX));
     rb_define_const(mConstants, "SEARCHLOG_MAX", INT2NUM(ZSTD_SEARCHLOG_MAX));
     rb_define_const(mConstants, "SEARCHLOG_MIN", INT2NUM(ZSTD_SEARCHLOG_MIN));
-    rb_define_const(mConstants, "SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
-    rb_define_const(mConstants, "SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
-    rb_define_const(mConstants, "TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
-    rb_define_const(mConstants, "TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
+    //rb_define_const(mConstants, "SEARCHLENGTH_MAX", INT2NUM(ZSTD_SEARCHLENGTH_MAX));
+    //rb_define_const(mConstants, "SEARCHLENGTH_MIN", INT2NUM(ZSTD_SEARCHLENGTH_MIN));
+    //rb_define_const(mConstants, "TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
+    //rb_define_const(mConstants, "TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
 }
 
 /*
@@ -329,7 +251,7 @@ extzstd_params_alloc(ZSTD_parameters **p)
  * [opts contentlog: nil]
  * [opts hashlog: nil]
  * [opts searchlog: nil]
- * [opts searchlength: nil]
+ * [opts minmatch: nil]
  * [opts targetlength: nil]
  * [opts strategy: nil]
  */
@@ -362,9 +284,12 @@ params_init(int argc, VALUE argv[], VALUE v)
         SETUP_PARAM(p->cParams.chainLog, opts, "chainlog", NUM2UINT);
         SETUP_PARAM(p->cParams.hashLog, opts, "hashlog", NUM2UINT);
         SETUP_PARAM(p->cParams.searchLog, opts, "searchlog", NUM2UINT);
-        SETUP_PARAM(p->cParams.searchLength, opts, "searchlength", NUM2UINT);
+        SETUP_PARAM(p->cParams.minMatch, opts, "minmatch", NUM2UINT);
         SETUP_PARAM(p->cParams.targetLength, opts, "targetlength", NUM2UINT);
         SETUP_PARAM(p->cParams.strategy, opts, "strategy", NUM2UINT);
+        SETUP_PARAM(p->fParams.contentSizeFlag, opts, "contentsize", RTEST);
+        SETUP_PARAM(p->fParams.checksumFlag, opts, "checksum", RTEST);
+        SETUP_PARAM(p->fParams.noDictIDFlag, opts, "nodictid", RTEST);
 #undef SETUP_PARAM
     }
 
@@ -408,7 +333,7 @@ IMP_PARAMS(params_windowlog, params_set_windowlog, windowLog);
 IMP_PARAMS(params_chainlog, params_set_chainlog, chainLog);
 IMP_PARAMS(params_hashlog, params_set_hashlog, hashLog);
 IMP_PARAMS(params_searchlog, params_set_searchlog, searchLog);
-IMP_PARAMS(params_searchlength, params_set_searchlength, searchLength);
+IMP_PARAMS(params_minmatch, params_set_minmatch, minMatch);
 IMP_PARAMS(params_targetlength, params_set_targetlength, targetLength);
 IMP_PARAMS(params_strategy, params_set_strategy, strategy);
 
@@ -461,8 +386,8 @@ params_s_get_preset(int argc, VALUE argv[], VALUE mod)
  * Document-method: Zstd::Parameters#hashlog=
  * Document-method: Zstd::Parameters#searchlog
  * Document-method: Zstd::Parameters#searchlog=
- * Document-method: Zstd::Parameters#searchlength
- * Document-method: Zstd::Parameters#searchlength=
+ * Document-method: Zstd::Parameters#minmatch
+ * Document-method: Zstd::Parameters#minmatch=
  * Document-method: Zstd::Parameters#targetlength
  * Document-method: Zstd::Parameters#targetlength=
  * Document-method: Zstd::Parameters#strategy
@@ -489,8 +414,8 @@ init_params(void)
     rb_define_method(extzstd_cParams, "hashlog=", RUBY_METHOD_FUNC(params_set_hashlog), 1);
     rb_define_method(extzstd_cParams, "searchlog", RUBY_METHOD_FUNC(params_searchlog), 0);
     rb_define_method(extzstd_cParams, "searchlog=", RUBY_METHOD_FUNC(params_set_searchlog), 1);
-    rb_define_method(extzstd_cParams, "searchlength", RUBY_METHOD_FUNC(params_searchlength), 0);
-    rb_define_method(extzstd_cParams, "searchlength=", RUBY_METHOD_FUNC(params_set_searchlength), 1);
+    rb_define_method(extzstd_cParams, "minmatch", RUBY_METHOD_FUNC(params_minmatch), 0);
+    rb_define_method(extzstd_cParams, "minmatch=", RUBY_METHOD_FUNC(params_set_minmatch), 1);
     rb_define_method(extzstd_cParams, "targetlength", RUBY_METHOD_FUNC(params_targetlength), 0);
     rb_define_method(extzstd_cParams, "targetlength=", RUBY_METHOD_FUNC(params_set_targetlength), 1);
     rb_define_method(extzstd_cParams, "strategy", RUBY_METHOD_FUNC(params_strategy), 0);
@@ -518,7 +443,8 @@ dict_s_train_from_buffer(VALUE mod, VALUE src, VALUE dict_capacity)
     size_t capa = NUM2SIZET(dict_capacity);
     VALUE dict = rb_str_buf_new(capa);
     size_t srcsize = RSTRING_LEN(src);
-    size_t s = ZDICT_trainFromBuffer(RSTRING_PTR(dict), capa, RSTRING_PTR(src), &srcsize, 1);
+    const ZDICT_legacy_params_t params = { 0 };
+    size_t s = ZDICT_trainFromBuffer_legacy(RSTRING_PTR(dict), capa, RSTRING_PTR(src), &srcsize, 1, params);
     extzstd_check_error(s);
     rb_str_set_len(dict, s);
     return dict;
@@ -688,9 +614,14 @@ init_contextless(void)
  * library initializer
  */
 
-void
+RBEXT_API void
 Init_extzstd(void)
 {
+    RB_EXT_RACTOR_SAFE(true);
+
+    id_initialize = rb_intern("initialize");
+    id_error_code = rb_intern("error_code");
+
     extzstd_mZstd = rb_define_module("Zstd");
 
     init_libver();

data/ext/extzstd.h

@@ -3,11 +3,14 @@
 
 #define ZSTD_LEGACY_SUPPORT 1
 #define ZDICT_STATIC_LINKING_ONLY 1
-#define ZSTD_STATIC_LINKING_ONLY 1
+//#define ZSTD_STATIC_LINKING_ONLY 1
+#include <common/zstd_internal.h> /* for MIN() */
 #include <zstd.h>
 #include <stdarg.h>
+#include <stdbool.h>
 #include <ruby.h>
 #include <ruby/thread.h>
+#include <ruby/version.h>
 
 #define ELEMENTOF(ARRAY) (sizeof(ARRAY) / sizeof(ARRAY[0]))
 #define ENDOF(ARRAY) (ARRAY + ELEMENTOF(ARRAY))
@@ -28,24 +31,6 @@ RDOCFAKE(extzstd_cParams = rb_define_class_under(extzstd_mZstd, "Parameters", rb
 
 extern VALUE extzstd_mExceptions;
 extern VALUE extzstd_eError;
-extern VALUE extzstd_eGenericError;
-extern VALUE extzstd_ePrefixUnknownError;
-extern VALUE extzstd_eFrameParameterUnsupportedError;
-extern VALUE extzstd_eFrameParameterUnsupportedBy32bitsError;
-extern VALUE extzstd_eCompressionParameterUnsupportedError;
-extern VALUE extzstd_eInitMissingError;
-extern VALUE extzstd_eMemoryAllocationError;
-extern VALUE extzstd_eStageWrongError;
-extern VALUE extzstd_eDstSizeTooSmallError;
-extern VALUE extzstd_eSrcSizeWrongError;
-extern VALUE extzstd_eCorruptionDetectedError;
-extern VALUE extzstd_eChecksumWrongError;
-extern VALUE extzstd_eTableLogTooLargeError;
-extern VALUE extzstd_eMaxSymbolValueTooLargeError;
-extern VALUE extzstd_eMaxSymbolValueTooSmallError;
-extern VALUE extzstd_eDictionaryCorruptedError;
-extern VALUE extzstd_eDictionaryWrongError;
-
 
 extern void init_extzstd_stream(void);
 extern void extzstd_init_buffered(void);
@@ -53,7 +38,7 @@ extern void extzstd_init_stream(void);
 extern void extzstd_error(ssize_t errcode);
 extern void extzstd_check_error(ssize_t errcode);
 extern VALUE extzstd_make_error(ssize_t errcode);
-extern VALUE extzstd_make_errorf(VALUE exc, const char *fmt, ...);
+extern VALUE extzstd_make_errorf(ssize_t errcode, const char *fmt, ...);
 
 extern ZSTD_parameters *extzstd_getparams(VALUE v);
 extern int extzstd_params_p(VALUE v);
@@ -171,16 +156,80 @@ aux_const_dig_str_0(VALUE obj, const char *p[], const char **pp)
     return obj;
 }
 
-#define aux_const_dig_str(OBJ, ...)                          \
-    ({                                                       \
-        const char *names__[] = { __VA_ARGS__ };             \
-        aux_const_dig_str_0((OBJ), names__, ENDOF(names__)); \
-    })                                                       \
-
-#define AUX_TUPLE(...)                      \
-    ({                                      \
-        VALUE v__[] = { __VA_ARGS__ };      \
-        rb_ary_new4(ELEMENTOF(v__), v__);   \
-    })                                      \
+#define aux_const_dig_str(OBJ, ...)                         \
+        aux_const_dig_str_0((OBJ),                          \
+                ((const char *[]){ __VA_ARGS__ }),          \
+                ENDOF(((const char *[]){ __VA_ARGS__ })))   \
+
+#define AUX_TUPLE(...)                                  \
+    rb_ary_new4(ELEMENTOF(((VALUE[]) { __VA_ARGS__ })), \
+            ((VALUE[]) { __VA_ARGS__ }))                \
+
+#define AUX_FUNCALL(RECV, MID, ...)                         \
+    rb_funcall2((RECV), (MID),                              \
+            ELEMENTOF(((const VALUE[]){ __VA_ARGS__ })),    \
+            ((const VALUE[]){ __VA_ARGS__ }))               \
+
+#define AUX_TRY_WITH_GC(cond, mesg) \
+    do {                            \
+        if (!(cond)) {              \
+            rb_gc();                \
+            if (!(cond)) {          \
+                errno = ENOMEM;     \
+                rb_sys_fail(mesg);  \
+            }                       \
+        }                           \
+    } while (0)                     \
+
+#if defined _WIN32 || defined __CYGWIN__
+#   define RBEXT_IMPORT __declspec(dllimport)
+#   define RBEXT_EXPORT __declspec(dllexport)
+#   define RBEXT_LOCAL
+#elif defined(__GNUC__) && __GNUC__ >= 4 || defined(__clang__)
+#   define RBEXT_IMPORT __attribute__((visibility("default")))
+#   define RBEXT_EXPORT __attribute__((visibility("default")))
+#   define RBEXT_LOCAL  __attribute__((visibility("hidden")))
+#else
+#   define RBEXT_IMPORT
+#   define RBEXT_EXPORT
+#   define RBEXT_LOCAL
+#endif
+
+#ifndef RBEXT_API
+#   define RBEXT_API RBEXT_EXPORT
+#endif
+
+
+static void
+aux_string_pointer(VALUE str, const char **ptr, size_t *size)
+{
+    rb_check_type(str, RUBY_T_STRING);
+    RSTRING_GETMEM(str, *ptr, *size);
+}
+
+static void
+aux_string_pointer_with_nil(VALUE str, const char **ptr, size_t *size)
+{
+    if (NIL_P(str)) {
+        *ptr = NULL;
+        *size = 0;
+    } else {
+        aux_string_pointer(str, ptr, size);
+    }
+}
+
+static void
+aux_string_expand_pointer(VALUE str, char **ptr, size_t size)
+{
+    rb_check_type(str, RUBY_T_STRING);
+    rb_str_modify(str);
+    rb_str_set_len(str, 0);
+    rb_str_modify_expand(str, size);
+    *ptr = RSTRING_PTR(str);
+}
+
+#if RUBY_API_VERSION_CODE >= 30000
+# define rb_obj_infect(dest, src) ((void)(dest), (void)(src))
+#endif
 
 #endif /* EXTZSTD_H */