extzstd 0.0.2.CONCEPT-x86-mingw32 → 0.0.3.CONCEPT-x86-mingw32

data/ext/extzstd.h

@@ -1,18 +1,61 @@
 #ifndef EXTZSTD_H
 #define EXTZSTD_H 1
 
+#define ZSTD_LEGACY_SUPPORT 1
+#define ZBUFF_STATIC_LINKING_ONLY 1
+#include <zbuff.h>
 #include <stdarg.h>
 #include <ruby.h>
 #include <ruby/thread.h>
-#include <zstd.h>
-#include <zstd_static.h>
+
+#define ELEMENTOF(ARRAY) (sizeof(ARRAY) / sizeof(ARRAY[0]))
+#define ENDOF(ARRAY) (ARRAY + ELEMENTOF(ARRAY))
+
+#define LOGF(MESG, ...)                                         \
+    do {                                                        \
+        fprintf(stderr, "%s:%d:%s: " MESG "\n",                 \
+                __FILE__, __LINE__, __func__, ## __VA_ARGS__);  \
+    } while (0)                                                 \
 
 #define RDOCFAKE(DUMMY_CODE)
 
-extern VALUE mZstd;
-extern VALUE eError;
+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));
+
+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);
+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, ...);
 
-void init_extzstd_stream(void);
+extern ZSTD_parameters *extzstd_getencparams(VALUE v);
+extern int extzstd_encparams_p(VALUE v);
+extern VALUE extzstd_params_alloc(ZSTD_parameters **p);
 
 static inline void
 referror(VALUE v)
@@ -51,29 +94,91 @@ getref(VALUE v, const rb_data_type_t *type)
     return checkref(v, getrefp(v, type));
 }
 
+#define AUX_IMPLEMENT_CONTEXT(TYPE, TYPEDDATANAME, STRUCTNAME, ALLOCNAME,   \
+                              MARKFUNC, FREEFUNC, SIZEFUNC,                 \
+                              GETREFP, GETREF, REF_P)                       \
+    static const rb_data_type_t TYPEDDATANAME = {                           \
+        .wrap_struct_name = STRUCTNAME,                                     \
+        .function.dmark = MARKFUNC,                                         \
+        .function.dfree = FREEFUNC,                                         \
+        .function.dsize = SIZEFUNC,                                         \
+    };                                                                      \
+                                                                            \
+    static VALUE                                                            \
+    ALLOCNAME(VALUE klass)                                                  \
+    {                                                                       \
+        return TypedData_Wrap_Struct(klass, &TYPEDDATANAME, NULL);          \
+    }                                                                       \
+                                                                            \
+    static inline TYPE *                                                    \
+    GETREFP(VALUE v)                                                        \
+    {                                                                       \
+        return getrefp(v, &TYPEDDATANAME);                                  \
+    }                                                                       \
+                                                                            \
+    static inline TYPE *                                                    \
+    GETREF(VALUE v)                                                         \
+    {                                                                       \
+        return getref(v, &TYPEDDATANAME);                                   \
+    }                                                                       \
+                                                                            \
+    static inline int                                                       \
+    REF_P(VALUE v)                                                          \
+    {                                                                       \
+        return rb_typeddata_is_kind_of(v, &TYPEDDATANAME);                  \
+    }                                                                       \
+
 static inline VALUE
-aux_str_modify_expand(VALUE s, size_t z)
+aux_str_modify_expand(VALUE str, size_t size)
 {
-    rb_check_type(s, RUBY_T_STRING);
-    size_t size = RSTRING_LEN(s);
-    if (z > size) {
-        rb_str_modify_expand(s, z - size);
+    size_t capa = rb_str_capacity(str);
+    if (capa < size) {
+        rb_str_modify_expand(str, size - RSTRING_LEN(str));
     } else {
-        rb_str_modify(s);
+        rb_str_modify(str);
     }
-    return s;
+    return str;
 }
 
-static inline void *
-aux_thread_call_without_gvl(void *(*func)(void *), void (*cancel)(void *), ...)
+static inline int
+aux_num2int(VALUE v, int default_value)
 {
-    va_list va1, va2;
-    va_start(va1, cancel);
-    va_start(va2, cancel);
-    void *p = rb_thread_call_without_gvl(func, &va1, cancel, &va2);
-    va_end(va1);
-    va_end(va2);
-    return p;
+    if (NIL_P(v)) {
+        return default_value;
+    } else {
+        return NUM2INT(v);
+    }
 }
 
-#endif /* !EXTZSTD_H */
+static inline uint64_t
+aux_num2int_u64(VALUE v, uint64_t default_value)
+{
+    if (NIL_P(v)) {
+        return default_value;
+    } else {
+        return NUM2ULL(v);
+    }
+}
+
+static inline VALUE
+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));
+    }
+    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__);   \
+    })                                      \
+
+#endif /* EXTZSTD_H */

data/ext/extzstd_buffered.c

@@ -0,0 +1,265 @@
+#include "extzstd.h"
+#include "extzstd_nogvls.h"
+
+/*
+ * class Zstd::BufferedEncoder
+ */
+
+static void
+bufenc_free(void *p)
+{
+    ZBUFF_freeCCtx(p);
+}
+
+AUX_IMPLEMENT_CONTEXT(
+        ZBUFF_CCtx, bufenc_datatype, "extzstd.BufferedEncoder",
+        bufenc_alloc_dummy, NULL, bufenc_free, NULL,
+        getbufencp, getbufenc, bufenc_p);
+
+static VALUE
+bufenc_alloc(VALUE mod)
+{
+    ZBUFF_CCtx *p = ZBUFF_createCCtx();
+    if (!p) {
+        rb_gc();
+        p = ZBUFF_createCCtx();
+        if (!p) {
+            rb_raise(extzstd_eError, "failed ZBUFF_createCCtx()");
+        }
+    }
+
+    return TypedData_Wrap_Struct(mod, &bufenc_datatype, p);
+}
+
+static VALUE
+bufenc_init(VALUE enc, VALUE params, VALUE dict)
+{
+    ZBUFF_CCtx *p = getbufenc(enc);
+    const void *dictp;
+    size_t dictsize;
+    if (NIL_P(dict)) {
+        dictp = NULL;
+        dictsize = 0;
+    } else {
+        rb_check_type(dict, RUBY_T_STRING);
+        RSTRING_GETMEM(dict, dictp, dictsize);
+    }
+    if (extzstd_encparams_p(params)) {
+        ZSTD_parameters *paramsp = extzstd_getencparams(params);
+        size_t s = aux_ZBUFF_compressInit_advanced(p, dictp, dictsize, paramsp, 0);
+        extzstd_check_error(s);
+    } else {
+        size_t s = aux_ZBUFF_compressInitDictionary(p, dictp, dictsize, aux_num2int(params, 1));
+        extzstd_check_error(s);
+    }
+
+    return enc;
+}
+
+static VALUE
+bufenc_continue(VALUE v, VALUE src, VALUE srcoff, VALUE dest, VALUE maxsize)
+{
+    ZBUFF_CCtx *p = getbufenc(v);
+    rb_check_type(src, RUBY_T_STRING);
+    char *srcp;
+    size_t srcsize;
+    RSTRING_GETMEM(src, srcp, srcsize);
+    size_t srcoff1 = NUM2SIZET(srcoff);
+    if ((srcsize > 0 && srcoff1 >= srcsize) || srcoff1 > srcsize) {
+        rb_raise(rb_eArgError,
+                "``srcoff'' is out of src size (%"PRIuSIZE" for 0...%"PRIuSIZE")",
+                srcoff1, srcsize);
+    }
+    srcp += srcoff1;
+    srcsize -= srcoff1;
+    size_t destsize = NUM2SIZET(maxsize);
+    rb_check_type(dest, RUBY_T_STRING);
+    aux_str_modify_expand(dest, destsize);
+    rb_obj_infect(v, src);
+    rb_obj_infect(dest, v);
+    size_t s = aux_ZBUFF_compressContinue(p, RSTRING_PTR(dest), &destsize, srcp, &srcsize);
+    extzstd_check_error(s);
+    rb_str_set_len(dest, destsize);
+    if (srcsize > 0) {
+        return SIZET2NUM(srcoff1 + srcsize);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+bufenc_flush(VALUE v, VALUE dest, VALUE maxsize)
+{
+    ZBUFF_CCtx *p = getbufenc(v);
+    size_t destsize = NUM2SIZET(maxsize);
+    rb_check_type(dest, RUBY_T_STRING);
+    aux_str_modify_expand(dest, destsize);
+    size_t s = aux_ZBUFF_compressFlush(p, RSTRING_PTR(dest), &destsize);
+    extzstd_check_error(s);
+    rb_str_set_len(dest, destsize);
+    return dest;
+}
+
+static VALUE
+bufenc_end(VALUE v, VALUE dest, VALUE maxsize)
+{
+    ZBUFF_CCtx *p = getbufenc(v);
+    size_t destsize = NUM2SIZET(maxsize);
+    rb_check_type(dest, RUBY_T_STRING);
+    aux_str_modify_expand(dest, destsize);
+    size_t s = aux_ZBUFF_compressEnd(p, RSTRING_PTR(dest), &destsize);
+    extzstd_check_error(s);
+    rb_str_set_len(dest, destsize);
+    return dest;
+}
+
+static VALUE
+bufenc_s_recommended_insize(VALUE mod)
+{
+    return SIZET2NUM(ZBUFF_recommendedCInSize());
+}
+
+static VALUE
+bufenc_s_recommended_outsize(VALUE mod)
+{
+    return SIZET2NUM(ZBUFF_recommendedCOutSize());
+}
+
+static void
+init_buffered_encoder(void)
+{
+    VALUE cBufEncoder = rb_define_class_under(extzstd_mZstd, "BufferedEncoder", rb_cObject);
+    rb_define_alloc_func(cBufEncoder, bufenc_alloc);
+    rb_define_method(cBufEncoder, "initialize", RUBY_METHOD_FUNC(bufenc_init), 2);
+    rb_define_method(cBufEncoder, "continue", RUBY_METHOD_FUNC(bufenc_continue), 4);
+    rb_define_method(cBufEncoder, "flush", RUBY_METHOD_FUNC(bufenc_flush), 2);
+    rb_define_method(cBufEncoder, "end", RUBY_METHOD_FUNC(bufenc_end), 2);
+    rb_define_singleton_method(cBufEncoder, "recommended_insize", RUBY_METHOD_FUNC(bufenc_s_recommended_insize), 0);
+    rb_define_singleton_method(cBufEncoder, "recommended_outsize", RUBY_METHOD_FUNC(bufenc_s_recommended_outsize), 0);
+}
+
+/*
+ * class Zstd::BufferedDecoder
+ */
+
+static void
+bufdec_free(void *p)
+{
+    ZBUFF_freeDCtx(p);
+}
+
+AUX_IMPLEMENT_CONTEXT(
+        ZBUFF_DCtx, bufdec_datatype, "extzstd.BufferedDecoder",
+        bufdec_alloc_dummy, NULL, bufdec_free, NULL,
+        getbufdecp, getbufdec, bufdec_p);
+
+static VALUE
+bufdec_alloc(VALUE mod)
+{
+    ZBUFF_DCtx *p = ZBUFF_createDCtx();
+    if (!p) {
+        rb_gc();
+        p = ZBUFF_createDCtx();
+        if (!p) {
+            rb_raise(extzstd_eError, "failed ZBUFF_createDCtx()");
+        }
+    }
+
+    return TypedData_Wrap_Struct(mod, &bufdec_datatype, p);
+}
+
+static VALUE
+bufdec_init(VALUE dec, VALUE dict)
+{
+    /*
+     * ZSTDLIB_API size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize);
+     */
+
+    ZBUFF_DCtx *p = getbufdec(dec);
+    if (!NIL_P(dict)) {
+        rb_check_type(dict, RUBY_T_STRING);
+        if (RSTRING_LEN(dict) > 0) {
+            dict = rb_str_new_frozen(dict);
+            rb_obj_infect(dec, dict);
+            size_t s = ZBUFF_decompressInitDictionary(p, RSTRING_PTR(dict), RSTRING_LEN(dict));
+            extzstd_check_error(s);
+            rb_iv_set(dec, "extzstd.dictionary for gc-guard", dict);
+            return dec;
+        }
+    }
+
+    size_t s = aux_ZBUFF_decompressInit(p);
+    extzstd_check_error(s);
+
+    return dec;
+}
+
+/*
+ * call-seq:
+ *  continue(src, srcoff, dest, maxdestsize) -> srcoff or nil
+ */
+static VALUE
+bufdec_continue(VALUE dec, VALUE src, VALUE srcoff, VALUE dest, VALUE maxdest)
+{
+    ZBUFF_DCtx *p = getbufdec(dec);
+    rb_check_type(src, RUBY_T_STRING);
+    rb_check_type(dest, RUBY_T_STRING);
+    const char *srcp;
+    size_t srcsize;
+    RSTRING_GETMEM(src, srcp, srcsize);
+    size_t srcoff1 = NUM2SIZET(srcoff);
+    if (srcoff1 >= srcsize) {
+        rb_raise(rb_eArgError,
+                "``srcoff'' is out of src size (%"PRIuSIZE" for 0...%"PRIuSIZE")",
+                srcoff1, srcsize);
+    }
+    srcp += srcoff1;
+    srcsize -= srcoff1;
+    size_t destsize = NUM2SIZET(maxdest);
+    aux_str_modify_expand(dest, destsize);
+    char *destp = RSTRING_PTR(dest);
+    rb_obj_infect(dec, src);
+    rb_obj_infect(dest, dec);
+    size_t s = aux_ZBUFF_decompressContinue(p, destp, &destsize, srcp, &srcsize);
+    extzstd_check_error(s);
+    rb_str_set_len(dest, destsize);
+    if (srcsize == 0) {
+        return Qnil;
+    } else {
+        return SIZET2NUM(srcoff1 + srcsize);
+    }
+}
+
+static VALUE
+bufdec_s_recommended_insize(VALUE mod)
+{
+    return SIZET2NUM(ZBUFF_recommendedDInSize());
+}
+
+static VALUE
+bufdec_s_recommended_outsize(VALUE mod)
+{
+    return SIZET2NUM(ZBUFF_recommendedDOutSize());
+}
+
+static void
+init_buffered_decoder(void)
+{
+    VALUE cBufDecoder = rb_define_class_under(extzstd_mZstd, "BufferedDecoder", rb_cObject);
+    rb_define_alloc_func(cBufDecoder, bufdec_alloc);
+    rb_define_method(cBufDecoder, "initialize", RUBY_METHOD_FUNC(bufdec_init), 1);
+    rb_define_method(cBufDecoder, "continue", RUBY_METHOD_FUNC(bufdec_continue), 4);
+    rb_define_singleton_method(cBufDecoder, "recommended_insize", RUBY_METHOD_FUNC(bufdec_s_recommended_insize), 0);
+    rb_define_singleton_method(cBufDecoder, "recommended_outsize", RUBY_METHOD_FUNC(bufdec_s_recommended_outsize), 0);
+}
+
+/*
+ * generic
+ */
+
+void
+extzstd_init_buffered(void)
+{
+    init_buffered_encoder();
+    init_buffered_decoder();
+}

data/ext/extzstd_nogvls.h

@@ -0,0 +1,174 @@
+#ifndef EXTZSTD_NOGVLS_H
+#define EXTZSTD_NOGVLS_H 1
+
+#include "extzstd.h"
+
+static inline void *
+aux_thread_call_without_gvl(void *(*func)(va_list *), void (*cancel)(va_list *), ...)
+{
+    va_list va1, va2;
+    va_start(va1, cancel);
+    va_start(va2, cancel);
+    void *p = rb_thread_call_without_gvl(
+            (void *(*)(void *))func, &va1,
+            (void (*)(void *))cancel, &va2);
+    va_end(va2);
+    va_end(va1);
+    return p;
+}
+
+static void *
+aux_ZSTD_compress_nogvl(va_list *vp)
+{
+    char *dest = va_arg(*vp, char *);
+    size_t destsize = va_arg(*vp, size_t);
+    const char *src = va_arg(*vp, const char *);
+    size_t srcsize = va_arg(*vp, size_t);
+    int level = va_arg(*vp, int);
+    return (void *)ZSTD_compress(dest, destsize, src, srcsize, level);
+}
+
+static inline size_t
+aux_ZSTD_compress(char *dest, size_t destsize, const char *src, size_t srcsize, int level)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZSTD_compress_nogvl, NULL,
+            dest, destsize, src, srcsize, level);
+}
+
+static void *
+aux_ZSTD_decompress_nogvl(va_list *vp)
+{
+    char *dest = va_arg(*vp, char *);
+    size_t destsize = va_arg(*vp, size_t);
+    const char *src = va_arg(*vp, const char *);
+    size_t srcsize = va_arg(*vp, size_t);
+    return (void *)ZSTD_decompress(dest, destsize, src, srcsize);
+}
+
+static inline size_t
+aux_ZSTD_decompress(char *dest, size_t destsize, const char *src, size_t srcsize)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZSTD_decompress_nogvl, NULL,
+            dest, destsize, src, srcsize);
+}
+
+static void *
+aux_ZBUFF_compressInit_nogvl(va_list *vp)
+{
+    ZBUFF_CCtx *p = va_arg(*vp, ZBUFF_CCtx *);
+    const void *dict = va_arg(*vp, const void *);
+    size_t dictsize = va_arg(*vp, size_t);
+    int level = va_arg(*vp, int);
+    return (void *)ZBUFF_compressInitDictionary(p, dict, dictsize, level);
+}
+
+static inline size_t
+aux_ZBUFF_compressInitDictionary(ZBUFF_CCtx *p, const void* dict, size_t dictsize, int level)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_compressInit_nogvl, NULL, p, dict, dictsize, level);
+}
+
+static inline void *
+aux_ZBUFF_compressInit_advanced_nogvl(va_list *vp)
+{
+    ZBUFF_CCtx *p = va_arg(*vp, ZBUFF_CCtx *);
+    const void *dict = va_arg(*vp, const void *);
+    size_t dictsize = va_arg(*vp, size_t);
+    const ZSTD_parameters *q = va_arg(*vp, const ZSTD_parameters *);
+    unsigned long long pledgedsrcsize = va_arg(*vp, unsigned long long);
+    return (void *)ZBUFF_compressInit_advanced(p, dict, dictsize, *q, pledgedsrcsize);
+}
+
+static inline size_t
+aux_ZBUFF_compressInit_advanced(ZBUFF_CCtx *p, const void *dict, size_t dictsize, const ZSTD_parameters *q, unsigned long long pledgedsrcsize)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_compressInit_advanced_nogvl, NULL, p, dict, dictsize, q, pledgedsrcsize);
+}
+
+static inline void *
+aux_ZBUFF_compressContinue_nogvl(va_list *vp)
+{
+    ZBUFF_CCtx *p = va_arg(*vp, ZBUFF_CCtx *);
+    char *destp = va_arg(*vp, char *);
+    size_t *destsize = va_arg(*vp, size_t *);
+    const char *srcp = va_arg(*vp, const char *);
+    size_t *srcsize = va_arg(*vp, size_t *);
+    return (void *)ZBUFF_compressContinue(p, destp, destsize, srcp, srcsize);
+}
+
+static inline size_t
+aux_ZBUFF_compressContinue(ZBUFF_CCtx *p, char *destp, size_t *destsize, const char *srcp, size_t *srcsize)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_compressContinue_nogvl, NULL, p, destp, destsize, srcp, srcsize);
+}
+
+static inline void *
+aux_ZBUFF_compressFlush_nogvl(va_list *vp)
+{
+    ZBUFF_CCtx *p = va_arg(*vp, ZBUFF_CCtx *);
+    char *destp = va_arg(*vp, char *);
+    size_t *destsize = va_arg(*vp, size_t *);
+    return (void *)ZBUFF_compressFlush(p, destp, destsize);
+}
+
+static inline size_t
+aux_ZBUFF_compressFlush(ZBUFF_CCtx *p, char *destp, size_t *destsize)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_compressFlush_nogvl, NULL, p, destp, destsize);
+}
+
+static inline void *
+aux_ZBUFF_compressEnd_nogvl(va_list *vp)
+{
+    ZBUFF_CCtx *p = va_arg(*vp, ZBUFF_CCtx *);
+    char *destp = va_arg(*vp, char *);
+    size_t *destsize = va_arg(*vp, size_t *);
+    return (void *)ZBUFF_compressEnd(p, destp, destsize);
+}
+
+static inline size_t
+aux_ZBUFF_compressEnd(ZBUFF_CCtx *p, char *destp, size_t *destsize)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_compressEnd_nogvl, NULL, p, destp, destsize);
+}
+
+static inline void *
+aux_ZBUFF_decompressInit_nogvl(va_list *vp)
+{
+    ZBUFF_DCtx *p = va_arg(*vp, ZBUFF_DCtx *);
+    return (void *)ZBUFF_decompressInit(p);
+}
+
+static inline size_t
+aux_ZBUFF_decompressInit(ZBUFF_DCtx *p)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_decompressInit_nogvl, NULL, p);
+}
+
+static inline void *
+aux_ZBUFF_decompressContinue_nogvl(va_list *vp)
+{
+    ZBUFF_DCtx *p = va_arg(*vp, ZBUFF_DCtx *);
+    char *destp = va_arg(*vp, char *);
+    size_t *destsize = va_arg(*vp, size_t *);
+    const char *srcp = va_arg(*vp, const char *);
+    size_t *srcsize = va_arg(*vp, size_t *);
+    return (void *)ZBUFF_decompressContinue(p, destp, destsize, srcp, srcsize);
+}
+
+static inline size_t
+aux_ZBUFF_decompressContinue(ZBUFF_DCtx *p, char *destp, size_t *destsize, const char *srcp, size_t *srcsize)
+{
+    return (size_t)aux_thread_call_without_gvl(
+            aux_ZBUFF_decompressContinue_nogvl, NULL, p, destp, destsize, srcp, srcsize);
+}
+
+#endif /* EXTZSTD_NOGVLS_H */