extzstd 0.0.3.CONCEPT → 0.1

data/ext/extzstd.c

@@ -1,8 +1,36 @@
 #include "extzstd.h"
-#include <mem.h>
-#include <error_public.h>
+#include <zstd/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);
+}
+
 VALUE extzstd_mZstd;
 
 /*
@@ -207,22 +235,29 @@ 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_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_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 +265,20 @@ 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, "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, "TARGETLENGTH_MAX", INT2NUM(ZSTD_TARGETLENGTH_MAX));
+    rb_define_const(mConstants, "TARGETLENGTH_MIN", INT2NUM(ZSTD_TARGETLENGTH_MIN));
 }
 
 /*
@@ -249,33 +288,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);
 }
 
 /*
@@ -291,42 +330,22 @@ extzstd_params_alloc(ZSTD_parameters **p)
  * [opts hashlog: nil]
  * [opts searchlog: nil]
  * [opts searchlength: 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);
 
@@ -344,6 +363,7 @@ encparams_init(int argc, VALUE argv[], VALUE v)
         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.targetLength, opts, "targetlength", NUM2UINT);
         SETUP_PARAM(p->cParams.strategy, opts, "strategy", NUM2UINT);
 #undef SETUP_PARAM
     }
@@ -352,10 +372,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 +383,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 +393,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_searchlength, params_set_searchlength, searchLength);
+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,66 +447,72 @@ 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#searchlength
+ * Document-method: Zstd::Parameters#searchlength=
+ * 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, "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, "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);
@@ -499,14 +526,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,19 +542,147 @@ 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
@@ -540,7 +696,8 @@ Init_extzstd(void)
     init_libver();
     init_error();
     init_constants();
-    init_encparams();
+    init_params();
     init_dictionary();
-    extzstd_init_buffered();
+    init_contextless();
+    extzstd_init_stream();
 }

data/ext/extzstd.h

@@ -2,8 +2,9 @@
 #define EXTZSTD_H 1
 
 #define ZSTD_LEGACY_SUPPORT 1
-#define ZBUFF_STATIC_LINKING_ONLY 1
-#include <zbuff.h>
+#define ZDICT_STATIC_LINKING_ONLY 1
+#define ZSTD_STATIC_LINKING_ONLY 1
+#include <zstd.h>
 #include <stdarg.h>
 #include <ruby.h>
 #include <ruby/thread.h>
@@ -23,7 +24,7 @@ extern VALUE extzstd_mZstd;
 RDOCFAKE(extzstd_mZstd = rb_define_module("Zstd"));
 
 extern VALUE extzstd_cParams;
-RDOCFAKE(extzstd_cParams = rb_define_class_under(extzstd_mZstd, "EncodeParameters", rb_cObject));
+RDOCFAKE(extzstd_cParams = rb_define_class_under(extzstd_mZstd, "Parameters", rb_cObject));
 
 extern VALUE extzstd_mExceptions;
 extern VALUE extzstd_eError;
@@ -48,13 +49,14 @@ extern VALUE extzstd_eDictionaryWrongError;
 
 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 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 ZSTD_parameters *extzstd_getencparams(VALUE v);
-extern int extzstd_encparams_p(VALUE v);
+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
@@ -161,7 +163,7 @@ aux_num2int_u64(VALUE v, uint64_t default_value)
 }
 
 static inline VALUE
-aux_const_dig_str_0(VALUE obj, const char *p[], const char *pp)
+aux_const_dig_str_0(VALUE obj, const char *p[], const char **pp)
 {
     for (; p < pp; p ++) {
         obj = rb_const_get(obj, rb_intern(*p));