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

data/contrib/zstd/zstd_static.h

@@ -1,89 +0,0 @@
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-2015, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#pragma once
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/**************************************
-*  Includes
-**************************************/
-#include "zstd.h"
-
-
-/**************************************
-*  Streaming functions
-**************************************/
-typedef struct ZSTD_Cctx_s ZSTD_Cctx;
-ZSTD_Cctx* ZSTD_createCCtx(void);
-size_t     ZSTD_freeCCtx(ZSTD_Cctx* cctx);
-
-size_t ZSTD_compressBegin(ZSTD_Cctx* cctx, void* dst, size_t maxDstSize);
-size_t ZSTD_compressContinue(ZSTD_Cctx* cctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-size_t ZSTD_compressEnd(ZSTD_Cctx* cctx, void* dst, size_t maxDstSize);
-
-
-typedef struct ZSTD_Dctx_s ZSTD_Dctx;
-ZSTD_Dctx* ZSTD_createDCtx(void);
-size_t     ZSTD_resetDCtx(ZSTD_Dctx* dctx);
-size_t     ZSTD_freeDCtx(ZSTD_Dctx* dctx);
-
-size_t ZSTD_nextSrcSizeToDecompress(ZSTD_Dctx* dctx);
-size_t ZSTD_decompressContinue(ZSTD_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-/*
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as input to ZSTD_decompressContinue().
-  This value is expected to be provided, precisely, as 'srcSize'.
-  Otherwise, compression will fail (result is an error code, which can be tested using ZSTD_isError() )
-  ZSTD_decompressContinue() result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-/**************************************
-*  Error management
-**************************************/
-#define ZSTD_LIST_ERRORS(ITEM) \
-        ITEM(ZSTD_OK_NoError) ITEM(ZSTD_ERROR_GENERIC) \
-        ITEM(ZSTD_ERROR_MagicNumber) \
-        ITEM(ZSTD_ERROR_SrcSize) ITEM(ZSTD_ERROR_maxDstSize_tooSmall) \
-        ITEM(ZSTD_ERROR_corruption) \
-        ITEM(ZSTD_ERROR_maxCode)
-
-#define ZSTD_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { ZSTD_LIST_ERRORS(ZSTD_GENERATE_ENUM) } ZSTD_errorCodes;   /* exposed list of errors; static linking only */
-
-
-#if defined (__cplusplus)
-}
-#endif

data/ext/extzstd-stream.c

@@ -1,398 +0,0 @@
-#include "extzstd.h"
-
-static ID id_op_lshift;
-
-#if 0
-static size_t
-aux_read(VALUE io, size_t size, char *buf)
-{
-    VALUE w = SEND(io, id_read, SIZET2NUM(size));
-    if (NIL_P(w)) { return 0; }
-    rb_check_type(w, RUBY_T_STRING);
-    size_t s = RSTRING_LEN(w);
-    if (s > size) {
-        rb_raise(rb_eRuntimeError,
-                "read size is too big - #<%s:%p> (size is %"PRIuSIZE" for %"PRIuSIZE")",
-                rb_obj_classname(io), (void *)io, s, size);
-    }
-    memcpy(buf, RSTRING_PTR(w), s);
-    return s;
-}
-#endif
-
-/*
- * class Zstd::Encoder
- */
-
-static VALUE cEncoder;
-
-struct encoder
-{
-    VALUE outport;
-    VALUE destbuf;
-    ZSTD_Cctx *encoder;
-};
-
-static void
-enc_mark(void *pp)
-{
-    if (pp) {
-        struct encoder *p = pp;
-        rb_gc_mark(p->outport);
-        rb_gc_mark(p->destbuf);
-    }
-}
-
-static void
-enc_free(void *pp)
-{
-    if (pp) {
-        struct encoder *p = pp;
-        if (p->encoder) {
-            ZSTD_freeCCtx(p->encoder);
-        }
-        if (!NIL_P(p->destbuf)) {
-            rb_str_resize(p->destbuf, 0);
-        }
-        free(p);
-    }
-}
-
-static const rb_data_type_t encoder_type = {
-    .wrap_struct_name = "extzstd.Zstd.Encoder",
-    .function.dmark = enc_mark,
-    .function.dfree = enc_free,
-    /* .function.dsize = enc_size, */
-};
-
-
-static VALUE
-enc_alloc(VALUE klass)
-{
-    struct encoder *p;
-    VALUE v = TypedData_Make_Struct(klass, struct encoder, &encoder_type, p);
-    p->outport = Qnil;
-    p->destbuf = Qnil;
-    p->encoder = NULL;
-    return v;
-}
-
-static inline struct encoder *
-getencoderp(VALUE enc)
-{
-    return getrefp(enc, &encoder_type);
-}
-
-static inline struct encoder *
-getencoder(VALUE enc)
-{
-    return getref(enc, &encoder_type);
-}
-
-static inline void
-enc_init_args(int argc, VALUE argv[], VALUE *outport)
-{
-    rb_scan_args(argc, argv, "01", outport);
-    if (NIL_P(*outport)) {
-        *outport = rb_str_buf_new(0);
-    }
-}
-
-/*
- * call-seq:
- *  initialize(outport) -> self
- *
- * +outport+ is required +.<<+ method for behavior as same as +IO#<<+ method.
- */
-static VALUE
-enc_init(int argc, VALUE argv[], VALUE enc)
-{
-    struct encoder *p = getencoder(enc);
-    if (p->encoder) { reiniterror(enc); }
-    enc_init_args(argc, argv, &p->outport);
-    p->destbuf = rb_str_buf_new(4 * 1024); /* FIXME: ``4 * 1024`` to constant value */
-    p->encoder = ZSTD_createCCtx();
-    if (!p->encoder) {
-        rb_raise(eError,
-                "failed ZSTD_createCCtx()");
-    }
-
-    size_t destsize = rb_str_capacity(p->destbuf);
-
-    size_t s = ZSTD_compressBegin(p->encoder, RSTRING_PTR(p->destbuf), destsize);
-    if (ZSTD_isError(s)) {
-        rb_raise(eError,
-                "failed ZSTD_compressBegin() - %s (%d)",
-                ZSTD_getErrorName(s), (int)s);
-    }
-
-    if (s > destsize) {
-        rb_bug("detect buffer overflow from in ZSTD_compressBegin() (destbuf.bytesize=%d, returned bytesize=%d)",
-               (int)RSTRING_LEN(p->destbuf), (int)s);
-    }
-
-    rb_str_set_len(p->destbuf, s);
-    rb_funcall2(p->outport, id_op_lshift, 1, &p->destbuf);
-
-    return enc;
-}
-
-/*
- * call-seq:
- *  write(src) -> self
- */
-static VALUE
-enc_write(int argc, VALUE argv[], VALUE enc)
-{
-    struct encoder *p = getencoder(enc);
-    if (!p->encoder) { referror(enc); }
-
-    VALUE src;
-    rb_scan_args(argc, argv, "1", &src);
-    rb_check_type(src, RUBY_T_STRING);
-
-    size_t destsize = ZSTD_compressBound(RSTRING_LEN(src)) + 64; /* FIXME: おそらくストリームブロックヘッダのようなものがくっつく */
-    rb_str_modify(p->destbuf);
-    rb_str_set_len(p->destbuf, 0);
-    rb_str_modify_expand(p->destbuf, destsize);
-    rb_obj_infect(enc, src);
-    rb_obj_infect(p->destbuf, enc);
-    size_t s = ZSTD_compressContinue(p->encoder, RSTRING_PTR(p->destbuf), destsize, RSTRING_PTR(src), RSTRING_LEN(src));
-    if (ZSTD_isError(s)) {
-        rb_raise(eError,
-                "failed ZSTD_compressContinue() - %s (%d)",
-                ZSTD_getErrorName(s), (int)s);
-    }
-
-    if (s > destsize) {
-        rb_bug("detect buffer overflow from in ZSTD_compressContinue() (destbuf.bytesize=%d, returned bytesize=%d)",
-               (int)RSTRING_LEN(p->destbuf), (int)s);
-    }
-
-    rb_str_set_len(p->destbuf, s);
-    rb_funcall2(p->outport, id_op_lshift, 1, &p->destbuf);
-
-    return enc;
-}
-
-/*
- * call-seq:
- *  finish -> self
- */
-static VALUE
-enc_finish(int argc, VALUE argv[], VALUE enc)
-{
-    struct encoder *p = getencoder(enc);
-    if (!p->encoder) { referror(enc); }
-
-    rb_scan_args(argc, argv, "0");
-
-    size_t destsize = 64; /* FIXME: ストリームフッターはどのくらい? */
-    rb_str_modify(p->destbuf);
-    rb_str_set_len(p->destbuf, 0);
-    rb_str_modify_expand(p->destbuf, destsize);
-
-    size_t s = ZSTD_compressEnd(p->encoder, RSTRING_PTR(p->destbuf), destsize);
-    if (ZSTD_isError(s)) {
-        rb_raise(eError,
-                "failed ZSTD_compressEnd() - %s (%d)",
-                ZSTD_getErrorName(s), (int)s);
-    }
-
-    if (s > destsize) {
-        rb_bug("detect buffer overflow from in ZSTD_compressEnd() (destbuf.bytesize=%d, returned bytesize=%d)",
-               (int)RSTRING_LEN(p->destbuf), (int)s);
-    }
-
-    rb_str_set_len(p->destbuf, s);
-    rb_funcall2(p->outport, id_op_lshift, 1, &p->destbuf);
-
-    return enc;
-}
-
-static VALUE
-enc_getoutport(VALUE enc)
-{
-    return getencoder(enc)->outport;
-}
-
-static VALUE
-enc_setoutport(VALUE enc, VALUE outport)
-{
-    return getencoder(enc)->outport = outport;
-}
-
-/*
- * class Zstd::LowLevelDecoder
- */
-
-static VALUE cLLDecoder;
-
-struct lldecoder
-{
-    ZSTD_Dctx *decoder;
-};
-
-static void
-lldec_mark(void *pp)
-{
-    if (pp) {
-        struct lldecoder *p = pp;
-    }
-}
-
-static void
-lldec_free(void *pp)
-{
-    if (pp) {
-        struct lldecoder *p = pp;
-        if (p->decoder) {
-            ZSTD_freeDCtx(p->decoder);
-        }
-        free(p);
-    }
-}
-
-static const rb_data_type_t lldecoder_type = {
-    .wrap_struct_name = "extzstd.Zstd.LowLevelDecoder",
-    .function.dmark = lldec_mark,
-    .function.dfree = lldec_free,
-    /* .function.dsize = lldec_size, */
-};
-
-
-static VALUE
-lldec_alloc(VALUE klass)
-{
-    struct lldecoder *p;
-    VALUE v = TypedData_Make_Struct(klass, struct lldecoder, &lldecoder_type, p);
-    p->decoder = NULL;
-    return v;
-}
-
-static inline struct lldecoder *
-getlldecoderp(VALUE v)
-{
-    return getrefp(v, &lldecoder_type);
-}
-
-static inline struct lldecoder *
-getlldecoder(VALUE v)
-{
-    return getref(v, &lldecoder_type);
-}
-
-/*
- * call-seq:
- *  initialize
- */
-static VALUE
-lldec_init(int argc, VALUE argv[], VALUE dec)
-{
-    struct lldecoder *p = getlldecoder(dec);
-    if (p->decoder) { reiniterror(dec); }
-    rb_check_arity(argc, 0, 0);
-    p->decoder = ZSTD_createDCtx();
-    if (!p->decoder) {
-        rb_raise(eError,
-                "failed ZSTD_createDCtx()");
-    }
-
-    ZSTD_resetDCtx(p->decoder);
-
-    return dec;
-}
-
-/*
- * call-seq:
- *  reset -> self
- */
-static VALUE
-lldec_reset(VALUE dec)
-{
-    struct lldecoder *p = getlldecoder(dec);
-    if (!p->decoder) { referror(dec); }
-    size_t s = ZSTD_resetDCtx(p->decoder);
-    if (ZSTD_isError(s)) {
-        rb_raise(eError,
-                "failed ZSTD_resetDCtx() - %s (%d)",
-                ZSTD_getErrorName(s), (int)s);
-    }
-    return dec;
-}
-
-/*
- * call-seq:
- *  next_srcsize -> next size as integer
- */
-static VALUE
-lldec_next_srcsize(VALUE dec)
-{
-    struct lldecoder *p = getlldecoder(dec);
-    if (!p->decoder) { referror(dec); }
-    size_t s = ZSTD_nextSrcSizeToDecompress(p->decoder);
-    if (ZSTD_isError(s)) {
-        rb_raise(eError,
-                "failed ZSTD_nextSrcSizeToDecompress() - %s (%d)",
-                ZSTD_getErrorName(s), (int)s);
-    }
-    return SIZET2NUM(s);
-}
-
-/*
- * call-seq:
- *  decode(src, dest, maxdestsize) -> dest OR nil
- */
-static VALUE
-lldec_decode(VALUE dec, VALUE src, VALUE dest, VALUE maxdestsize)
-{
-    struct lldecoder *p = getlldecoder(dec);
-    if (!p->decoder) { referror(dec); }
-
-    rb_obj_infect(dec, src);
-    rb_obj_infect(dest, dec);
-    const char *srcp = StringValuePtr(src);
-    size_t srcsize = RSTRING_LEN(src);
-    size_t destsize = NUM2UINT(maxdestsize); /* サイズ制限のために NUM2UINT にしている */
-    aux_str_modify_expand(dest, destsize);
-    char *destp = RSTRING_PTR(dest);
-    size_t s = ZSTD_decompressContinue(p->decoder, destp, destsize, srcp, srcsize);
-    if (ZSTD_isError(s)) {
-        rb_raise(eError,
-                "failed ZSTD_decompressContinue() - %s (%d)",
-                ZSTD_getErrorName(s), (int)s);
-    }
-    rb_str_set_len(dest, s);
-    if (s == 0) {
-        return Qnil;
-    } else {
-        return dest;
-    }
-}
-
-/*
- * initializer for Zstd::Encoder and Zstd::LowLevelDecoder
- */
-
-void
-init_extzstd_stream(void)
-{
-    id_op_lshift = rb_intern("<<");
-
-    RDOCFAKE(mZstd = rb_define_module("Zstd"));
-
-    cEncoder = rb_define_class_under(mZstd, "Encoder", rb_cObject);
-    rb_define_alloc_func(cEncoder, enc_alloc);
-    rb_define_method(cEncoder, "initialize", RUBY_METHOD_FUNC(enc_init), -1);
-    rb_define_method(cEncoder, "write", RUBY_METHOD_FUNC(enc_write), -1);
-    rb_define_method(cEncoder, "finish", RUBY_METHOD_FUNC(enc_finish), -1);
-    rb_define_method(cEncoder, "outport", RUBY_METHOD_FUNC(enc_getoutport), 0);
-    rb_define_method(cEncoder, "outport=", RUBY_METHOD_FUNC(enc_setoutport), 1);
-
-    cLLDecoder = rb_define_class_under(mZstd, "LowLevelDecoder", rb_cObject);
-    rb_define_alloc_func(cLLDecoder, lldec_alloc);
-    rb_define_method(cLLDecoder, "initialize", RUBY_METHOD_FUNC(lldec_init), -1);
-    rb_define_method(cLLDecoder, "reset", RUBY_METHOD_FUNC(lldec_reset), 0);
-    rb_define_method(cLLDecoder, "next_srcsize", RUBY_METHOD_FUNC(lldec_next_srcsize), 0);
-    rb_define_method(cLLDecoder, "decode", RUBY_METHOD_FUNC(lldec_decode), 3);
-}