extzstd 0.3.2 → 0.4

data/contrib/zstd/lib/{common/zstd_errors.h → zstd_errors.h}

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  * All rights reserved.
  *
  * This source code is licensed under both the BSD-style license (found in the
@@ -20,19 +20,31 @@ extern "C" {
 
 
 /* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
-#ifndef ZSTDERRORLIB_VISIBILITY
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define ZSTDERRORLIB_VISIBILITY __attribute__ ((visibility ("default")))
+#ifndef ZSTDERRORLIB_VISIBLE
+   /* Backwards compatibility with old macro name */
+#  ifdef ZSTDERRORLIB_VISIBILITY
+#    define ZSTDERRORLIB_VISIBLE ZSTDERRORLIB_VISIBILITY
+#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_VISIBLE __attribute__ ((visibility ("default")))
 #  else
-#    define ZSTDERRORLIB_VISIBILITY
+#    define ZSTDERRORLIB_VISIBLE
 #  endif
 #endif
+
+#ifndef ZSTDERRORLIB_HIDDEN
+#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_HIDDEN __attribute__ ((visibility ("hidden")))
+#  else
+#    define ZSTDERRORLIB_HIDDEN
+#  endif
+#endif
+
 #if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBILITY
+#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBLE
 #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
-#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
 #else
-#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBILITY
+#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBLE
 #endif
 
 /*-*********************************************
@@ -58,14 +70,17 @@ typedef enum {
   ZSTD_error_frameParameter_windowTooLarge = 16,
   ZSTD_error_corruption_detected = 20,
   ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_literals_headerWrong = 24,
   ZSTD_error_dictionary_corrupted      = 30,
   ZSTD_error_dictionary_wrong          = 32,
   ZSTD_error_dictionaryCreation_failed = 34,
   ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_combination_unsupported = 41,
   ZSTD_error_parameter_outOfBound    = 42,
   ZSTD_error_tableLog_tooLarge       = 44,
   ZSTD_error_maxSymbolValue_tooLarge = 46,
   ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_stabilityCondition_notRespected = 50,
   ZSTD_error_stage_wrong       = 60,
   ZSTD_error_init_missing      = 62,
   ZSTD_error_memory_allocation = 64,
@@ -73,11 +88,15 @@ typedef enum {
   ZSTD_error_dstSize_tooSmall = 70,
   ZSTD_error_srcSize_wrong    = 72,
   ZSTD_error_dstBuffer_null   = 74,
+  ZSTD_error_noForwardProgress_destFull = 80,
+  ZSTD_error_noForwardProgress_inputEmpty = 82,
   /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
   ZSTD_error_frameIndex_tooLarge = 100,
   ZSTD_error_seekableIO          = 102,
   ZSTD_error_dstBuffer_wrong     = 104,
   ZSTD_error_srcBuffer_wrong     = 105,
+  ZSTD_error_sequenceProducer_failed = 106,
+  ZSTD_error_externalSequences_invalid = 107,
   ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
 } ZSTD_ErrorCode;
 

data/ext/extconf.rb

@@ -2,6 +2,19 @@
 
 require "mkmf"
 
+using Module.new {
+  refine Object do
+    def has_function_modifier?(modifier_code)
+      try_compile(<<~CODE)
+        #{modifier_code}
+        void
+        func1(void) {
+        }
+      CODE
+    end
+  end
+}
+
 $INCFLAGS = %w(
   -I$(srcdir)/../contrib
   -I$(srcdir)/../contrib/zstd/lib
@@ -10,12 +23,13 @@ $INCFLAGS = %w(
   -I$(srcdir)/../contrib/zstd/lib/legacy
 ).join(" ") + " #$INCFLAGS"
 
-#dir = File.dirname(__FILE__).gsub(/[\[\{\?\*]/, "[\\0]")
-#filepattern = "{.,../contrib/zstd}/**/*.c"
-#target = File.join(dir, filepattern)
-#files = Dir.glob(target).sort.map { |n| File.basename n }
-#$srcs = files
-#$VPATH.push "$(srcdir)/../contrib/zstd", "$(srcdir)/../contrib/zstd/legacy"
+#if libzstd が 1.5.1 以降で gcc/clang であれば
+  dir = __dir__
+  dir1 = dir.gsub(/[\[\{\?\*]/, "[\\0]")
+  filepattern = "**/*.[cS]"
+  target = File.join(dir1, filepattern)
+  $srcs = Dir.glob(target).sort
+#end
 
 if RbConfig::CONFIG["arch"] =~ /mingw/i
   $LDFLAGS << " -static-libgcc" if try_ldflags("-static-libgcc")
@@ -25,9 +39,14 @@ __attribute__ ((visibility("hidden"))) int conftest(void) { return 0; }
   VISIBILITY
     if try_cflags("-fvisibility=hidden")
       $CFLAGS << " -fvisibility=hidden"
-      $defs << %('-DRBEXT_API=__attribute__ ((visibility("default")))')
+      $defs << %(-DRBEXT_API='__attribute__ ((visibility("default")))')
     end
   end
 end
 
+mod = %w(__attribute__((__noreturn__)) __declspec(noreturn) [[noreturn]] _Noreturn).find { |m|
+  has_function_modifier?(m)
+}
+$defs << %(-DRBEXT_NORETURN='#{mod}')
+
 create_makefile File.join(RUBY_VERSION.slice(/\d+\.\d+/), "extzstd")

data/ext/extzstd.c

@@ -71,6 +71,7 @@ extzstd_check_error(ssize_t errcode)
     }
 }
 
+RBEXT_NORETURN
 void
 extzstd_error(ssize_t errcode)
 {
@@ -80,8 +81,6 @@ extzstd_error(ssize_t errcode)
 VALUE
 extzstd_make_errorf(ssize_t errcode, const char *fmt, ...)
 {
-    VALUE e;
-
     if (fmt && strlen(fmt) > 0) {
         VALUE args[] = { SSIZET2NUM(errcode), Qnil };
         va_list va;
@@ -171,13 +170,14 @@ init_constants(void)
     rb_define_const(mConstants, "ZSTD_HASHLOG_MIN", INT2NUM(ZSTD_HASHLOG_MIN));
     rb_define_const(mConstants, "ZSTD_CHAINLOG_MAX", INT2NUM(ZSTD_CHAINLOG_MAX));
     rb_define_const(mConstants, "ZSTD_CHAINLOG_MIN", INT2NUM(ZSTD_CHAINLOG_MIN));
-    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_MINMATCH_MAX", INT2NUM(ZSTD_MINMATCH_MAX));
+    rb_define_const(mConstants, "ZSTD_MINMATCH_MIN", INT2NUM(ZSTD_MINMATCH_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_STRATEGY_MIN", INT2NUM(ZSTD_STRATEGY_MIN));
+    rb_define_const(mConstants, "ZSTD_STRATEGY_MAX", INT2NUM(ZSTD_STRATEGY_MAX));
 
     rb_define_const(mConstants, "FAST", INT2NUM(ZSTD_fast));
     rb_define_const(mConstants, "DFAST", INT2NUM(ZSTD_dfast));
@@ -194,13 +194,15 @@ init_constants(void)
     rb_define_const(mConstants, "HASHLOG_MIN", INT2NUM(ZSTD_HASHLOG_MIN));
     rb_define_const(mConstants, "CHAINLOG_MAX", INT2NUM(ZSTD_CHAINLOG_MAX));
     rb_define_const(mConstants, "CHAINLOG_MIN", INT2NUM(ZSTD_CHAINLOG_MIN));
-    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, "MINMATCH_MAX", INT2NUM(ZSTD_MINMATCH_MAX));
+    rb_define_const(mConstants, "MINMATCH_MIN", INT2NUM(ZSTD_MINMATCH_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, "STRATEGY_MIN", INT2NUM(ZSTD_STRATEGY_MIN));
+    rb_define_const(mConstants, "STRATEGY_MAX", INT2NUM(ZSTD_STRATEGY_MAX));
+
 }
 
 /*
@@ -458,17 +460,22 @@ static VALUE
 dict_s_add_entropy_tables_from_buffer(VALUE mod, VALUE dict, VALUE dict_capacity, VALUE sample)
 {
     /*
-     * size_t ZDICT_addEntropyTablesFromBuffer(
-     *      void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
-     *      const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples);
+     * ZDICTLIB_API size_t ZDICT_finalizeDictionary(void* dstDictBuffer, size_t maxDictSize,
+     *                                 const void* dictContent, size_t dictContentSize,
+     *                                 const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+     *                                 ZDICT_params_t parameters);
      */
 
     rb_check_type(dict, RUBY_T_STRING);
     rb_check_type(sample, RUBY_T_STRING);
     size_t capa = NUM2SIZET(dict_capacity);
     aux_str_modify_expand(dict, capa);
+    char *destptr = RSTRING_PTR(dict);
+    size_t destlen = RSTRING_LEN(dict);
+    const char *sampleptr = RSTRING_PTR(sample);
     size_t samplesize = RSTRING_LEN(sample);
-    size_t s = ZDICT_addEntropyTablesFromBuffer(RSTRING_PTR(dict), RSTRING_LEN(dict), capa, RSTRING_PTR(sample), &samplesize, 1);
+    ZDICT_params_t params = { 0, 0, 0 };
+    size_t s = ZDICT_finalizeDictionary(destptr, capa, destptr, destlen, sampleptr, &samplesize, 1, params);
     extzstd_check_error(s);
     rb_str_set_len(dict, s);
     return dict;
@@ -536,15 +543,32 @@ less_s_encode(VALUE mod, VALUE src, VALUE dest, VALUE maxdest, VALUE predict, VA
 
     if (extzstd_params_p(params)) {
         /*
-         * ZSTDLIB_API size_t ZSTD_compress_advanced(
-         *      ZSTD_CCtx* ctx,
-         *      void* dst, size_t dstCapacity,
-         *      const void* src, size_t srcSize,
-         *      const void* dict,size_t dictSize,
-         *      ZSTD_parameters params);
+         * ZSTDLIB_API size_t ZSTD_compress2( ZSTD_CCtx* cctx,
+         *                                    void* dst, size_t dstCapacity,
+         *                              const void* src, size_t srcSize);
+         * ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);
+         * ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);
          */
         ZSTD_CCtx *zstd = ZSTD_createCCtx();
-        size_t s = ZSTD_compress_advanced(zstd, r, rsize, q, qsize, d, dsize, *extzstd_getparams(params));
+        ZSTD_parameters *param = extzstd_getparams(params);
+
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_windowLog, param->cParams.windowLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_chainLog, param->cParams.chainLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_hashLog, param->cParams.hashLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_searchLog, param->cParams.searchLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_minMatch, param->cParams.minMatch);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_targetLength, param->cParams.targetLength);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_strategy, param->cParams.strategy);
+
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_contentSizeFlag, param->fParams.contentSizeFlag);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_checksumFlag, param->fParams.checksumFlag);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_dictIDFlag, !param->fParams.noDictIDFlag);
+
+        //aux_ZSTD_CCtx_setPledgedSrcSize(zstd, (unsigned long long)qsize);
+
+        aux_ZSTD_CCtx_loadDictionary(zstd, d, dsize);
+
+        size_t s = ZSTD_compress2(zstd, r, rsize, q, qsize);
         ZSTD_freeCCtx(zstd);
         extzstd_check_error(s);
         rb_str_set_len(dest, s);
@@ -584,7 +608,7 @@ less_s_decode(VALUE mod, VALUE src, VALUE dest, VALUE maxdest, VALUE predict)
     aux_string_pointer(src, &q, &qsize);
 
     char *r;
-    size_t rsize = (NIL_P(maxdest)) ? ZSTD_getDecompressedSize(q, qsize) : NUM2SIZET(maxdest);
+    size_t rsize = (NIL_P(maxdest)) ? ZSTD_getFrameContentSize(q, qsize) : NUM2SIZET(maxdest);
     aux_string_expand_pointer(dest, &r, rsize);
     rb_obj_infect(dest, src);
 
@@ -631,4 +655,7 @@ Init_extzstd(void)
     init_dictionary();
     init_contextless();
     extzstd_init_stream();
+
+    (void)params_alloc_dummy;
+    (void)getparamsp;
 }

data/ext/extzstd.h

@@ -35,7 +35,7 @@ extern VALUE extzstd_eError;
 extern void init_extzstd_stream(void);
 extern void extzstd_init_buffered(void);
 extern void extzstd_init_stream(void);
-extern void extzstd_error(ssize_t errcode);
+extern RBEXT_NORETURN 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(ssize_t errcode, const char *fmt, ...);
@@ -44,7 +44,7 @@ extern ZSTD_parameters *extzstd_getparams(VALUE v);
 extern int extzstd_params_p(VALUE v);
 extern VALUE extzstd_params_alloc(ZSTD_parameters **p);
 
-static inline void
+static RBEXT_NORETURN inline void
 referror(VALUE v)
 {
     rb_raise(rb_eRuntimeError,
@@ -52,7 +52,7 @@ referror(VALUE v)
              rb_obj_classname(v), (void *)v);
 }
 
-static inline void
+static RBEXT_NORETURN inline void
 reiniterror(VALUE v)
 {
     rb_raise(rb_eRuntimeError,
@@ -200,14 +200,14 @@ aux_const_dig_str_0(VALUE obj, const char *p[], const char **pp)
 #endif
 
 
-static void
+static inline 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
+static inline void
 aux_string_pointer_with_nil(VALUE str, const char **ptr, size_t *size)
 {
     if (NIL_P(str)) {
@@ -218,7 +218,7 @@ aux_string_pointer_with_nil(VALUE str, const char **ptr, size_t *size)
     }
 }
 
-static void
+static inline void
 aux_string_expand_pointer(VALUE str, char **ptr, size_t size)
 {
     rb_check_type(str, RUBY_T_STRING);
@@ -232,4 +232,31 @@ aux_string_expand_pointer(VALUE str, char **ptr, size_t size)
 # define rb_obj_infect(dest, src) ((void)(dest), (void)(src))
 #endif
 
+#define MAKE_AUX_FUNC(auxdecl, funcall, cleanup)                        \
+    static inline size_t                                                \
+    auxdecl                                                             \
+    {                                                                   \
+        size_t s = funcall;                                             \
+                                                                        \
+        if (ZSTD_isError(s)) {                                          \
+            cleanup;                                                    \
+            extzstd_error(s);                                           \
+        }                                                               \
+                                                                        \
+        return s;                                                       \
+    }                                                                   \
+
+MAKE_AUX_FUNC(aux_ZSTD_CCtx_reset(ZSTD_CCtx *zstd, ZSTD_ResetDirective reset),
+              ZSTD_CCtx_reset(zstd, reset),
+              ZSTD_freeCCtx(zstd))
+MAKE_AUX_FUNC(aux_ZSTD_CCtx_setParameter(ZSTD_CCtx *ctx, ZSTD_cParameter param, int value),
+              ZSTD_CCtx_setParameter(ctx, param, value),
+              ZSTD_freeCCtx(ctx))
+MAKE_AUX_FUNC(aux_ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx *ctx, unsigned long long pledgedSrcSize),
+              ZSTD_CCtx_setPledgedSrcSize(ctx, pledgedSrcSize),
+              ZSTD_freeCCtx(ctx))
+MAKE_AUX_FUNC(aux_ZSTD_CCtx_loadDictionary(ZSTD_CCtx *ctx, const void* dict, size_t dictSize),
+              ZSTD_CCtx_loadDictionary(ctx, dict, dictSize),
+              ZSTD_freeCCtx(ctx))
+
 #endif /* EXTZSTD_H */

data/ext/extzstd_stream.c

@@ -9,12 +9,13 @@ enum {
 };
 
 static inline VALUE
-aux_str_buf_recycle(VALUE str, size_t capacity)
+aux_str_buf_recycle(VALUE *str, size_t capacity)
 {
-    if (!RTEST(str) || rb_obj_frozen_p(str) || !rb_type_p(str, RUBY_T_STRING)) {
-        return rb_str_buf_new(capacity);
+    if (!RTEST(*str) || rb_obj_frozen_p(*str) || !rb_type_p(*str, RUBY_T_STRING)) {
+        *str = rb_str_buf_new(capacity);
+        return *str;
     } else {
-        return aux_str_modify_expand(str, capacity);
+        return aux_str_modify_expand(*str, capacity);
     }
 }
 
@@ -128,10 +129,6 @@ enc_init(int argc, VALUE argv[], VALUE self)
                 rb_obj_classname(self), (void *)self);
     }
 
-    AUX_TRY_WITH_GC(
-            p->context = ZSTD_createCStream(),
-            "failed ZSTD_createCStream()");
-
     const void *predictp;
     size_t predictsize;
     if (NIL_P(predict)) {
@@ -143,13 +140,39 @@ enc_init(int argc, VALUE argv[], VALUE self)
         RSTRING_GETMEM(predict, predictp, predictsize);
     }
 
+    AUX_TRY_WITH_GC(
+            p->context = ZSTD_createCStream(),
+            "failed ZSTD_createCStream()");
+
     if (extzstd_params_p(params)) {
         ZSTD_parameters *paramsp = extzstd_getparams(params);
-        size_t s = ZSTD_initCStream_advanced(p->context, predictp, predictsize, *paramsp, -1);
-        extzstd_check_error(s);
+        ZSTD_CCtx *zstd = p->context;
+        p->context = NULL; // 一時的に無効化する
+
+        aux_ZSTD_CCtx_reset(zstd, ZSTD_reset_session_and_parameters);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_windowLog, paramsp->cParams.windowLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_chainLog, paramsp->cParams.chainLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_hashLog, paramsp->cParams.hashLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_searchLog, paramsp->cParams.searchLog);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_minMatch, paramsp->cParams.minMatch);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_targetLength, paramsp->cParams.targetLength);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_strategy, paramsp->cParams.strategy);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_contentSizeFlag, paramsp->fParams.contentSizeFlag);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_checksumFlag, paramsp->fParams.checksumFlag);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_dictIDFlag, !paramsp->fParams.noDictIDFlag);
+        aux_ZSTD_CCtx_loadDictionary(zstd, predictp, predictsize);
+
+        p->context = zstd;
     } else {
-        size_t s = ZSTD_initCStream_usingDict(p->context, predictp, predictsize, aux_num2int(params, 1));
-        extzstd_check_error(s);
+        int clevel = aux_num2int(params, ZSTD_CLEVEL_DEFAULT);
+        ZSTD_CCtx *zstd = p->context;
+        p->context = NULL; // 一時的に無効化する
+
+        aux_ZSTD_CCtx_reset(zstd, ZSTD_reset_session_and_parameters);
+        aux_ZSTD_CCtx_setParameter(zstd, ZSTD_c_compressionLevel, clevel);
+        aux_ZSTD_CCtx_loadDictionary(zstd, predictp, predictsize);
+
+        p->context = zstd;
     }
 
     p->predict = predict;
@@ -170,7 +193,7 @@ enc_write(VALUE self, VALUE src)
     ZSTD_inBuffer input = { RSTRING_PTR(src), RSTRING_LEN(src), 0 };
 
     while (input.pos < input.size) {
-        p->destbuf = aux_str_buf_recycle(p->destbuf, ZSTD_CStreamOutSize() * 2);
+        aux_str_buf_recycle(&p->destbuf, ZSTD_CStreamOutSize() * 2);
         rb_str_set_len(p->destbuf, 0);
         rb_obj_infect(self, src);
         rb_obj_infect(p->destbuf, self);
@@ -195,7 +218,7 @@ enc_sync(VALUE self)
      */
 
     struct encoder *p = encoder_context(self);
-    aux_str_buf_recycle(p->destbuf, ZSTD_CStreamOutSize());
+    aux_str_buf_recycle(&p->destbuf, ZSTD_CStreamOutSize());
     rb_str_set_len(p->destbuf, 0);
     rb_obj_infect(p->destbuf, self);
     ZSTD_outBuffer output = { RSTRING_PTR(p->destbuf), rb_str_capacity(p->destbuf), 0 };
@@ -216,7 +239,7 @@ enc_close(VALUE self)
      */
 
     struct encoder *p = encoder_context(self);
-    aux_str_buf_recycle(p->destbuf, ZSTD_CStreamOutSize());
+    aux_str_buf_recycle(&p->destbuf, ZSTD_CStreamOutSize());
     rb_str_set_len(p->destbuf, 0);
     rb_obj_infect(p->destbuf, self);
     ZSTD_outBuffer output = { RSTRING_PTR(p->destbuf), rb_str_capacity(p->destbuf), 0 };
@@ -241,11 +264,18 @@ static VALUE
 enc_reset(VALUE self, VALUE pledged_srcsize)
 {
     /*
-     * ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
+     * ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);
      */
 
-    size_t s = ZSTD_resetCStream(encoder_context(self)->context, NUM2ULL(pledged_srcsize));
+    size_t s = ZSTD_CCtx_reset(encoder_context(self)->context, ZSTD_reset_session_only);
     extzstd_check_error(s);
+
+    if (pledged_srcsize == Qnil) {
+        ZSTD_CCtx_setPledgedSrcSize(encoder_context(self)->context, ZSTD_CONTENTSIZE_UNKNOWN);
+    } else {
+        ZSTD_CCtx_setPledgedSrcSize(encoder_context(self)->context, NUM2ULL(pledged_srcsize));
+    }
+
     return self;
 }
 
@@ -281,6 +311,10 @@ init_encoder(void)
     rb_define_alias(cStreamEncoder, "flush", "sync");
     rb_define_alias(cStreamEncoder, "end", "close");
     rb_define_alias(cStreamEncoder, "finish", "close");
+
+    (void)encoder_alloc_dummy;
+    (void)getencoderp;
+    (void)encoder_p;
 }
 
 /*
@@ -291,7 +325,7 @@ static VALUE cStreamDecoder;
 
 struct decoder
 {
-    ZSTD_DStream *context;
+    ZSTD_DCtx *context;
     VALUE inport;
     VALUE readbuf;
     VALUE predict;
@@ -313,7 +347,7 @@ dec_free(void *pp)
 {
     struct decoder *p = (struct decoder *)pp;
     if (p->context) {
-        ZSTD_freeDStream(p->context);
+        ZSTD_freeDCtx(p->context);
         p->context = NULL;
     }
     xfree(p);
@@ -352,6 +386,8 @@ static VALUE
 dec_init(int argc, VALUE argv[], VALUE self)
 {
     /*
+     * ZSTDLIB_API size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
+     *
      * ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
      * ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
      */
@@ -379,16 +415,19 @@ dec_init(int argc, VALUE argv[], VALUE self)
     }
 
     AUX_TRY_WITH_GC(
-            p->context = ZSTD_createDStream(),
-            "failed ZSTD_createDStream()");
+            p->context = ZSTD_createDCtx(),
+            "failed ZSTD_createDCtx()");
 
+    //ZSTD_DCtx_reset
+    //ZSTD_DCtx_loadDictionary
     if (NIL_P(predict)) {
-        size_t s = ZSTD_initDStream(p->context);
-        extzstd_check_error(s);
+        //size_t s = ZSTD_initDStream(p->context);
+        //extzstd_check_error(s);
     } else {
         rb_check_type(predict, RUBY_T_STRING);
         predict = rb_str_new_frozen(predict);
-        size_t s = ZSTD_initDStream_usingDict(p->context, RSTRING_PTR(predict), RSTRING_LEN(predict));
+        //size_t s = ZSTD_initDStream_usingDict(p->context, RSTRING_PTR(predict), RSTRING_LEN(predict));
+        size_t s = ZSTD_DCtx_loadDictionary(p->context, RSTRING_PTR(predict), RSTRING_LEN(predict));
         extzstd_check_error(s);
     }
 
@@ -401,8 +440,8 @@ dec_init(int argc, VALUE argv[], VALUE self)
 static int
 dec_read_fetch(VALUE o, struct decoder *p)
 {
-    if (!p->inbuf.src || NIL_P(p->readbuf) || p->inbuf.pos >= RSTRING_LEN(p->readbuf)) {
-        p->readbuf = aux_str_buf_recycle(p->readbuf, EXT_PARTIAL_READ_SIZE);
+    if (!p->inbuf.src || NIL_P(p->readbuf) || p->inbuf.pos >= (size_t)RSTRING_LEN(p->readbuf)) {
+        aux_str_buf_recycle(&p->readbuf, EXT_PARTIAL_READ_SIZE);
         VALUE st = AUX_FUNCALL(p->inport, id_read, INT2FIX(EXT_PARTIAL_READ_SIZE), p->readbuf);
         if (NIL_P(st)) { return -1; }
         rb_check_type(st, RUBY_T_STRING);
@@ -420,13 +459,14 @@ dec_read_fetch(VALUE o, struct decoder *p)
 static size_t
 dec_read_decode(VALUE o, struct decoder *p, char *buf, ssize_t size)
 {
+
     if (p->reached_eof != 0) {
         return 0;
     }
 
     ZSTD_outBuffer output = { buf, size, 0 };
 
-    while (size < 0 || output.pos < size) {
+    while (size < 0 || output.pos < (size_t)size) {
         if (dec_read_fetch(o, p) != 0) {
             if (p->reached_eof == 0) {
                 rb_raise(rb_eRuntimeError,
@@ -563,10 +603,9 @@ dec_close(VALUE self)
 static VALUE
 dec_reset(VALUE self)
 {
-    /*
-     * ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
-     */
-    size_t s = ZSTD_resetDStream(decoder_context(self)->context);
+    //> ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);
+
+    size_t s = ZSTD_DCtx_reset(decoder_context(self)->context, ZSTD_reset_session_only);
     extzstd_check_error(s);
     return self;
 }
@@ -605,6 +644,10 @@ init_decoder(void)
     rb_define_method(cStreamDecoder, "reset", dec_reset, 0);
     rb_define_method(cStreamDecoder, "sizeof", dec_sizeof, 0);
     rb_define_method(cStreamDecoder, "pos", dec_pos, 0);
+
+    (void)decoder_alloc_dummy;
+    (void)getdecoderp;
+    (void)decoder_p;
 }
 
 /*

data/ext/libzstd_conf.h

@@ -2,7 +2,6 @@
 #define RUBY_ZSTD_LIBZSTD_CONF_H 1
 
 #define ZSTD_LEGACY_SUPPORT 1
-#define MEM_MODULE 1
 #define visibility(v) visibility("hidden")
 
 #endif /* RUBY_ZSTD_LIBZSTD_CONF_H */

data/ext/zstd_decompress_asm.S

@@ -0,0 +1 @@
+#include "../contrib/zstd/lib/decompress/huf_decompress_amd64.S"