extzstd 0.0.3.CONCEPT → 0.3.1

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

@@ -2,9 +2,13 @@
 
 require "mkmf"
 
-find_header "zstd.h", "$(srcdir)/../contrib/zstd/common" or abort "can't find ``zstd.h''"
-find_header "zdict.h", "$(srcdir)/../contrib/zstd/dictBuilder" or abort "can't find ``zdict.h''"
-find_header "zstd_legacy.h", "$(srcdir)/../contrib/zstd/legacy" or abort "can't find ``zstd_legacy.h''"
+$INCFLAGS = %w(
+  -I$(srcdir)/../contrib
+  -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]")
 #filepattern = "{.,../contrib/zstd}/**/*.c"
@@ -13,8 +17,17 @@ find_header "zstd_legacy.h", "$(srcdir)/../contrib/zstd/legacy" or abort "can't
 #$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,10 +1,13 @@
 #include "extzstd.h"
-#include <mem.h>
-#include <error_public.h>
+#include <zstd/lib/common/mem.h>
+#include <zstd_errors.h>
 #include <zdict.h>
 
 VALUE extzstd_mZstd;
 
+static ID id_initialize;
+static ID id_error_code;
+
 /*
  * constant Zstd::LIBRARY_VERSION
  */
@@ -55,25 +58,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)
@@ -90,16 +74,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);
     }
 }
 
@@ -108,33 +96,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;
+}
+
+static VALUE
+err_errcode(VALUE err)
+{
+    return rb_ivar_get(err, id_error_code);
+}
 
-#undef CASE_ERROR
+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
@@ -144,57 +133,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");
 }
 
 /*
@@ -207,22 +149,31 @@ init_constants(void)
     VALUE mConstants = rb_define_module_under(extzstd_mZstd, "Constants");
     rb_include_module(extzstd_mZstd, mConstants);
 
+    rb_define_const(mConstants, "ZSTD_MAX_COMPRESSION_LEVEL", INT2NUM(ZSTD_maxCLevel()));
+    rb_define_const(mConstants, "MAX_COMPRESSION_LEVEL", INT2NUM(ZSTD_maxCLevel()));
+
     rb_define_const(mConstants, "ZSTD_FAST", INT2NUM(ZSTD_fast));
     rb_define_const(mConstants, "ZSTD_DFAST", INT2NUM(ZSTD_dfast));
     rb_define_const(mConstants, "ZSTD_GREEDY", INT2NUM(ZSTD_greedy));
     rb_define_const(mConstants, "ZSTD_LAZY", INT2NUM(ZSTD_lazy));
     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_CHAINLOG_MAX", INT2NUM(ZSTD_CHAINLOG_MAX));
-    rb_define_const(mConstants, "ZSTD_CHAINLOG_MIN", INT2NUM(ZSTD_CHAINLOG_MIN));
     rb_define_const(mConstants, "ZSTD_HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
     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_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));
@@ -230,16 +181,22 @@ init_constants(void)
     rb_define_const(mConstants, "LAZY", INT2NUM(ZSTD_lazy));
     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, "CHAINLOG_MAX", INT2NUM(ZSTD_CHAINLOG_MAX));
-    rb_define_const(mConstants, "CHAINLOG_MIN", INT2NUM(ZSTD_CHAINLOG_MIN));
     rb_define_const(mConstants, "HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
     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, "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));
 }
 
 /*
@@ -249,33 +206,33 @@ init_constants(void)
 VALUE extzstd_cParams;
 
 AUX_IMPLEMENT_CONTEXT(
-        ZSTD_parameters, encparams_type, "extzstd.EncodeParameters",
-        encparams_alloc_dummy, NULL, free, NULL,
-        getencparamsp, getencparams, encparams_p);
+        ZSTD_parameters, params_type, "extzstd.Parameters",
+        params_alloc_dummy, NULL, free, NULL,
+        getparamsp, getparams, params_p);
 
 ZSTD_parameters *
-extzstd_getencparams(VALUE v)
+extzstd_getparams(VALUE v)
 {
-    return getencparams(v);
+    return getparams(v);
 }
 
 int
-extzstd_encparams_p(VALUE v)
+extzstd_params_p(VALUE v)
 {
-    return encparams_p(v);
+    return params_p(v);
 }
 
 static VALUE
-encparams_alloc(VALUE mod)
+params_alloc(VALUE mod)
 {
     ZSTD_parameters *p;
-    return TypedData_Make_Struct(mod, ZSTD_parameters, &encparams_type, p);
+    return TypedData_Make_Struct(mod, ZSTD_parameters, &params_type, p);
 }
 
 VALUE
 extzstd_params_alloc(ZSTD_parameters **p)
 {
-    return TypedData_Make_Struct(extzstd_cParams, ZSTD_parameters, &encparams_type, *p);
+    return TypedData_Make_Struct(extzstd_cParams, ZSTD_parameters, &params_type, *p);
 }
 
 /*
@@ -290,43 +247,23 @@ 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]
  */
 static VALUE
-encparams_init(int argc, VALUE argv[], VALUE v)
+params_init(int argc, VALUE argv[], VALUE v)
 {
-    ZSTD_parameters *p = getencparams(v);
+    ZSTD_parameters *p = getparams(v);
     uint64_t sizehint;
     size_t dictsize;
     int level;
     VALUE opts = Qnil;
-    int argc0 = argc;
-    if (argc > 0) {
-        if (rb_type_p(argv[argc - 1], RUBY_T_HASH)) {
-            opts = argv[argc - 1];
-            argc --;
-        }
-    }
-    if (argc == 0) {
-        level = 0;
-        sizehint = 0;
-        dictsize = 0;
-    } else if (argc == 1) {
-        level = aux_num2int(argv[0], 0);
-        sizehint = 0;
-        dictsize = 0;
-    } else if (argc == 2) {
-        level = aux_num2int(argv[0], 0);
-        sizehint = aux_num2int_u64(argv[1], 0);
-        dictsize = 0;
-    } else if (argc == 3) {
-        level = aux_num2int(argv[0], 0);
-        sizehint = aux_num2int_u64(argv[1], 0);
-        dictsize = aux_num2int_u64(argv[2], 0);
-    } else {
-        rb_raise(rb_eArgError, "wrong number of argument (%d for 0..3 with keywords)", argc0);
-    }
+
+    argc = rb_scan_args(argc, argv, "03:", NULL, NULL, NULL, &opts);
+    level = argc > 0 ? aux_num2int(argv[0], 0) : 0;
+    sizehint = argc > 1 ? aux_num2int_u64(argv[1], 0) : 0;
+    dictsize = argc > 2 ? aux_num2int_u64(argv[2], 0) : 0;
 
     *p = ZSTD_getParams(level, sizehint, dictsize);
 
@@ -343,8 +280,12 @@ encparams_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
     }
 
@@ -352,10 +293,10 @@ encparams_init(int argc, VALUE argv[], VALUE v)
 }
 
 static VALUE
-encparams_init_copy(VALUE params, VALUE src)
+params_init_copy(VALUE params, VALUE src)
 {
-    ZSTD_parameters *a = getencparams(params);
-    ZSTD_parameters *b = getencparams(src);
+    ZSTD_parameters *a = getparams(params);
+    ZSTD_parameters *b = getparams(src);
     rb_check_frozen(params);
     rb_obj_infect(params, src);
     memcpy(a, b, sizeof(*a));
@@ -363,9 +304,9 @@ encparams_init_copy(VALUE params, VALUE src)
 }
 
 //static VALUE
-//encparams_validate(VALUE v)
+//params_validate(VALUE v)
 //{
-//    ZSTD_validateParams(getencparams(v));
+//    ZSTD_validateParams(getparams(v));
 //    return v;
 //}
 
@@ -373,28 +314,29 @@ encparams_init_copy(VALUE params, VALUE src)
     static VALUE                                            \
     GETTER(VALUE v)                                         \
     {                                                       \
-        return UINT2NUM(getencparams(v)->cParams.FIELD);    \
+        return UINT2NUM(getparams(v)->cParams.FIELD);    \
     }                                                       \
                                                             \
     static VALUE                                            \
     SETTER(VALUE v, VALUE n)                                \
     {                                                       \
-        getencparams(v)->cParams.FIELD = NUM2UINT(n);       \
+        getparams(v)->cParams.FIELD = NUM2UINT(n);       \
         return n;                                           \
     }                                                       \
 
-//IMP_PARAMS(encparams_srcsize, encparams_set_srcsize, srcSize);
-IMP_PARAMS(encparams_windowlog, encparams_set_windowlog, windowLog);
-IMP_PARAMS(encparams_chainlog, encparams_set_chainlog, chainLog);
-IMP_PARAMS(encparams_hashlog, encparams_set_hashlog, hashLog);
-IMP_PARAMS(encparams_searchlog, encparams_set_searchlog, searchLog);
-IMP_PARAMS(encparams_searchlength, encparams_set_searchlength, searchLength);
-IMP_PARAMS(encparams_strategy, encparams_set_strategy, strategy);
+//IMP_PARAMS(params_srcsize, params_set_srcsize, srcSize);
+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_minmatch, params_set_minmatch, minMatch);
+IMP_PARAMS(params_targetlength, params_set_targetlength, targetLength);
+IMP_PARAMS(params_strategy, params_set_strategy, strategy);
 
 #undef IMP_PARAMS
 
 static VALUE
-encparams_s_get_preset(int argc, VALUE argv[], VALUE mod)
+params_s_get_preset(int argc, VALUE argv[], VALUE mod)
 {
     int level;
     uint64_t sizehint;
@@ -426,72 +368,79 @@ encparams_s_get_preset(int argc, VALUE argv[], VALUE mod)
     }
 
     ZSTD_parameters *p;
-    VALUE v = TypedData_Make_Struct(mod, ZSTD_parameters, &encparams_type, p);
+    VALUE v = TypedData_Make_Struct(mod, ZSTD_parameters, &params_type, p);
     *p = ZSTD_getParams(level, sizehint, dictsize);
     return v;
 }
 
 /*
- * Document-method: Zstd::EncodeParameters#windowlog
- * Document-method: Zstd::EncodeParameters#windowlog=
- * Document-method: Zstd::EncodeParameters#chainlog
- * Document-method: Zstd::EncodeParameters#chainlog=
- * Document-method: Zstd::EncodeParameters#hashlog
- * Document-method: Zstd::EncodeParameters#hashlog=
- * Document-method: Zstd::EncodeParameters#searchlog
- * Document-method: Zstd::EncodeParameters#searchlog=
- * Document-method: Zstd::EncodeParameters#searchlength
- * Document-method: Zstd::EncodeParameters#searchlength=
- * Document-method: Zstd::EncodeParameters#strategy
- * Document-method: Zstd::EncodeParameters#strategy=
+ * Document-method: Zstd::Parameters#windowlog
+ * Document-method: Zstd::Parameters#windowlog=
+ * Document-method: Zstd::Parameters#chainlog
+ * Document-method: Zstd::Parameters#chainlog=
+ * Document-method: Zstd::Parameters#hashlog
+ * Document-method: Zstd::Parameters#hashlog=
+ * Document-method: Zstd::Parameters#searchlog
+ * Document-method: Zstd::Parameters#searchlog=
+ * 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
+ * Document-method: Zstd::Parameters#strategy=
  *
  * Get/Set any field from/to struct ZSTD_parameters of C layer.
  */
 
 static void
-init_encparams(void)
+init_params(void)
 {
-    extzstd_cParams = rb_define_class_under(extzstd_mZstd, "EncodeParameters", rb_cObject);
-    rb_define_alloc_func(extzstd_cParams, encparams_alloc);
-    rb_define_method(extzstd_cParams, "initialize", RUBY_METHOD_FUNC(encparams_init), -1);
-    rb_define_method(extzstd_cParams, "initialize_copy", RUBY_METHOD_FUNC(encparams_init_copy), 1);
-    //rb_define_method(extzstd_cParams, "validate", RUBY_METHOD_FUNC(encparams_validate), 0);
-    //rb_define_method(extzstd_cParams, "srcsize", RUBY_METHOD_FUNC(encparams_srcsize), 0);
-    //rb_define_method(extzstd_cParams, "srcsize=", RUBY_METHOD_FUNC(encparams_set_srcsize), 1);
-    rb_define_method(extzstd_cParams, "windowlog", RUBY_METHOD_FUNC(encparams_windowlog), 0);
-    rb_define_method(extzstd_cParams, "windowlog=", RUBY_METHOD_FUNC(encparams_set_windowlog), 1);
-    rb_define_method(extzstd_cParams, "chainlog", RUBY_METHOD_FUNC(encparams_chainlog), 0);
-    rb_define_method(extzstd_cParams, "chainlog=", RUBY_METHOD_FUNC(encparams_set_chainlog), 1);
-    rb_define_method(extzstd_cParams, "hashlog", RUBY_METHOD_FUNC(encparams_hashlog), 0);
-    rb_define_method(extzstd_cParams, "hashlog=", RUBY_METHOD_FUNC(encparams_set_hashlog), 1);
-    rb_define_method(extzstd_cParams, "searchlog", RUBY_METHOD_FUNC(encparams_searchlog), 0);
-    rb_define_method(extzstd_cParams, "searchlog=", RUBY_METHOD_FUNC(encparams_set_searchlog), 1);
-    rb_define_method(extzstd_cParams, "searchlength", RUBY_METHOD_FUNC(encparams_searchlength), 0);
-    rb_define_method(extzstd_cParams, "searchlength=", RUBY_METHOD_FUNC(encparams_set_searchlength), 1);
-    rb_define_method(extzstd_cParams, "strategy", RUBY_METHOD_FUNC(encparams_strategy), 0);
-    rb_define_method(extzstd_cParams, "strategy=", RUBY_METHOD_FUNC(encparams_set_strategy), 1);
-
-    rb_define_singleton_method(extzstd_cParams, "preset", RUBY_METHOD_FUNC(encparams_s_get_preset), -1);
+    extzstd_cParams = rb_define_class_under(extzstd_mZstd, "Parameters", rb_cObject);
+    rb_define_alloc_func(extzstd_cParams, params_alloc);
+    rb_define_method(extzstd_cParams, "initialize", RUBY_METHOD_FUNC(params_init), -1);
+    rb_define_method(extzstd_cParams, "initialize_copy", RUBY_METHOD_FUNC(params_init_copy), 1);
+    //rb_define_method(extzstd_cParams, "validate", RUBY_METHOD_FUNC(params_validate), 0);
+    //rb_define_method(extzstd_cParams, "srcsize", RUBY_METHOD_FUNC(params_srcsize), 0);
+    //rb_define_method(extzstd_cParams, "srcsize=", RUBY_METHOD_FUNC(params_set_srcsize), 1);
+    rb_define_method(extzstd_cParams, "windowlog", RUBY_METHOD_FUNC(params_windowlog), 0);
+    rb_define_method(extzstd_cParams, "windowlog=", RUBY_METHOD_FUNC(params_set_windowlog), 1);
+    rb_define_method(extzstd_cParams, "chainlog", RUBY_METHOD_FUNC(params_chainlog), 0);
+    rb_define_method(extzstd_cParams, "chainlog=", RUBY_METHOD_FUNC(params_set_chainlog), 1);
+    rb_define_method(extzstd_cParams, "hashlog", RUBY_METHOD_FUNC(params_hashlog), 0);
+    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, "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);
+    rb_define_method(extzstd_cParams, "strategy=", RUBY_METHOD_FUNC(params_set_strategy), 1);
+
+    rb_define_singleton_method(extzstd_cParams, "preset", RUBY_METHOD_FUNC(params_s_get_preset), -1);
     rb_define_alias(rb_singleton_class(extzstd_cParams), "[]", "preset");
 }
 
 
 /*
- * zstd dictionary utilities
+ * module Zstd::Dictionary
  */
 
+static VALUE mDictionary;
+
 /*
  * call-seq:
- *  dict_train_from_buffer(src, dict_capacity) -> dictionary'd string
+ *  train_from_buffer(src, dict_capacity) -> dictionary'd string
  */
 static VALUE
-ext_s_dict_train_from_buffer(VALUE mod, VALUE src, VALUE dict_capacity)
+dict_s_train_from_buffer(VALUE mod, VALUE src, VALUE dict_capacity)
 {
     rb_check_type(src, RUBY_T_STRING);
     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;
@@ -499,14 +448,15 @@ ext_s_dict_train_from_buffer(VALUE mod, VALUE src, VALUE dict_capacity)
 
 /*
  * call-seq:
- *  dict_add_entropy_tables_from_buffer(dict, dict_capacity, sample) -> dict
+ *  add_entropy_tables_from_buffer(dict, dict_capacity, sample) -> dict
  */
 static VALUE
-ext_s_dict_add_entropy_tables_from_buffer(VALUE mod, VALUE dict, VALUE dict_capacity, VALUE sample)
+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);
+     * size_t ZDICT_addEntropyTablesFromBuffer(
+     *      void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
+     *      const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples);
      */
 
     rb_check_type(dict, RUBY_T_STRING);
@@ -514,33 +464,165 @@ ext_s_dict_add_entropy_tables_from_buffer(VALUE mod, VALUE dict, VALUE dict_capa
     size_t capa = NUM2SIZET(dict_capacity);
     aux_str_modify_expand(dict, capa);
     size_t samplesize = RSTRING_LEN(sample);
-    size_t s = ZDICT_addEntropyTablesFromBuffer(RSTRING_PTR(dict), RSTRING_LEN(dict), capa, RSTRING_PTR(dict), &samplesize, 1);
+    size_t s = ZDICT_addEntropyTablesFromBuffer(RSTRING_PTR(dict), RSTRING_LEN(dict), capa, RSTRING_PTR(sample), &samplesize, 1);
     extzstd_check_error(s);
     rb_str_set_len(dict, s);
     return dict;
 }
 
+static VALUE
+dict_s_getid(VALUE mod, VALUE dict)
+{
+    /*
+     * ZDICTLIB_API unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize);
+     */
+
+    rb_check_type(dict, RUBY_T_STRING);
+    const char *p;
+    size_t psize;
+    RSTRING_GETMEM(dict, p, psize);
+
+    size_t s = ZDICT_getDictID(p, psize);
+    extzstd_check_error(s);
+
+    return SIZET2NUM(s);
+}
+
 static void
 init_dictionary(void)
 {
-    rb_define_singleton_method(extzstd_mZstd, "dict_train_from_buffer", ext_s_dict_train_from_buffer, 2);
-    rb_define_singleton_method(extzstd_mZstd, "dict_add_entropy_tables_from_buffer", ext_s_dict_add_entropy_tables_from_buffer, 3);
+    mDictionary = rb_define_module_under(extzstd_mZstd, "Dictionary");
+    rb_define_singleton_method(mDictionary, "train_from_buffer", dict_s_train_from_buffer, 2);
+    rb_define_singleton_method(mDictionary, "add_entropy_tables_from_buffer", dict_s_add_entropy_tables_from_buffer, 3);
+    rb_define_singleton_method(mDictionary, "getid", dict_s_getid, 1);
+}
+
+/*
+ * module Zstd::ContextLess
+ */
+
+static VALUE mContextLess;
+
+/*
+ * call-seq:
+ *  encode(src, dest, maxdest, params)
+ *
+ * [RETURN] dest
+ * [src (string)]
+ * [dest (string)]
+ * [maxdest (integer or nil)]
+ * [params (nil, integer or Zstd::Parameters)]
+ */
+static VALUE
+less_s_encode(VALUE mod, VALUE src, VALUE dest, VALUE maxdest, VALUE predict, VALUE params)
+{
+    const char *q;
+    size_t qsize;
+    aux_string_pointer(src, &q, &qsize);
+
+    char *r;
+    size_t rsize = (NIL_P(maxdest)) ? ZSTD_compressBound(qsize) : NUM2SIZET(maxdest);
+    aux_string_expand_pointer(dest, &r, rsize);
+    rb_obj_infect(dest, src);
+
+    const char *d;
+    size_t dsize;
+    aux_string_pointer_with_nil(predict, &d, &dsize);
+    rb_obj_infect(dest, predict);
+
+    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);
+         */
+        ZSTD_CCtx *zstd = ZSTD_createCCtx();
+        size_t s = ZSTD_compress_advanced(zstd, r, rsize, q, qsize, d, dsize, *extzstd_getparams(params));
+        ZSTD_freeCCtx(zstd);
+        extzstd_check_error(s);
+        rb_str_set_len(dest, s);
+        return dest;
+    } else {
+        /*
+         * ZSTDLIB_API size_t ZSTD_compress_usingDict(
+         *      ZSTD_CCtx* ctx,
+         *      void* dst, size_t dstCapacity,
+         *      const void* src, size_t srcSize,
+         *      const void* dict,size_t dictSize,
+         *      int compressionLevel);
+         */
+        ZSTD_CCtx *zstd = ZSTD_createCCtx();
+        size_t s = ZSTD_compress_usingDict(zstd, r, rsize, q, qsize, d, dsize, aux_num2int(params, 0));
+        ZSTD_freeCCtx(zstd);
+        extzstd_check_error(s);
+        rb_str_set_len(dest, s);
+        return dest;
+    }
+}
+
+/*
+ * call-seq:
+ *  decode(src, dest, maxdest)
+ *
+ * [RETURN] dest
+ * [src (string)]
+ * [dest (string)]
+ * [maxdest (integer or nil)]
+ */
+static VALUE
+less_s_decode(VALUE mod, VALUE src, VALUE dest, VALUE maxdest, VALUE predict)
+{
+    const char *q;
+    size_t qsize;
+    aux_string_pointer(src, &q, &qsize);
+
+    char *r;
+    size_t rsize = (NIL_P(maxdest)) ? ZSTD_getDecompressedSize(q, qsize) : NUM2SIZET(maxdest);
+    aux_string_expand_pointer(dest, &r, rsize);
+    rb_obj_infect(dest, src);
+
+    const char *d;
+    size_t dsize;
+    aux_string_pointer_with_nil(predict, &d, &dsize);
+    rb_obj_infect(dest, predict);
+
+    ZSTD_DCtx *z = ZSTD_createDCtx();
+    size_t s = ZSTD_decompress_usingDict(z, r, rsize, q, qsize, d, dsize);
+    ZSTD_freeDCtx(z);
+    extzstd_check_error(s);
+    rb_str_set_len(dest, s);
+
+    return dest;
 }
 
+static void
+init_contextless(void)
+{
+    mContextLess = rb_define_module_under(extzstd_mZstd, "ContextLess");
+    rb_define_singleton_method(mContextLess, "encode", less_s_encode, 5);
+    rb_define_singleton_method(mContextLess, "decode", less_s_decode, 4);
+}
 
 /*
  * library initializer
  */
 
-void
+RBEXT_API void
 Init_extzstd(void)
 {
+    id_initialize = rb_intern("initialize");
+    id_error_code = rb_intern("error_code");
+
     extzstd_mZstd = rb_define_module("Zstd");
 
     init_libver();
     init_error();
     init_constants();
-    init_encparams();
+    init_params();
     init_dictionary();
-    extzstd_init_buffered();
+    init_contextless();
+    extzstd_init_stream();
 }