extlz4 0.3.4 → 0.3.5

data/contrib/lz4/lib/lz4hc.h

@@ -44,7 +44,7 @@ extern "C" {
 
 
 /* --- Useful constants --- */
-#define LZ4HC_CLEVEL_MIN         3
+#define LZ4HC_CLEVEL_MIN         2
 #define LZ4HC_CLEVEL_DEFAULT     9
 #define LZ4HC_CLEVEL_OPT_MIN    10
 #define LZ4HC_CLEVEL_MAX        12
@@ -126,6 +126,8 @@ LZ4LIB_API int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
 
   After reset, a first "fictional block" can be designated as initial dictionary,
   using LZ4_loadDictHC() (Optional).
+  Note: In order for LZ4_loadDictHC() to create the correct data structure,
+  it is essential to set the compression level _before_ loading the dictionary.
 
   Invoke LZ4_compress_HC_continue() to compress each successive block.
   The number of blocks is unlimited.
@@ -135,12 +137,12 @@ LZ4LIB_API int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
   It's allowed to update compression level anytime between blocks,
   using LZ4_setCompressionLevel() (experimental).
 
-  'dst' buffer should be sized to handle worst case scenarios
+ @dst buffer should be sized to handle worst case scenarios
   (see LZ4_compressBound(), it ensures compression success).
   In case of failure, the API does not guarantee recovery,
   so the state _must_ be reset.
   To ensure compression success
-  whenever `dst` buffer size cannot be made >= LZ4_compressBound(),
+  whenever @dst buffer size cannot be made >= LZ4_compressBound(),
   consider using LZ4_compress_HC_continue_destSize().
 
   Whenever previous input blocks can't be preserved unmodified in-place during compression of next blocks,
@@ -176,6 +178,34 @@ LZ4LIB_API int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr
 LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize);
 
 
+/*! LZ4_attach_HC_dictionary() : stable since v1.10.0
+ *  This API allows for the efficient re-use of a static dictionary many times.
+ *
+ *  Rather than re-loading the dictionary buffer into a working context before
+ *  each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a
+ *  working LZ4_streamHC_t, this function introduces a no-copy setup mechanism,
+ *  in which the working stream references the dictionary stream in-place.
+ *
+ *  Several assumptions are made about the state of the dictionary stream.
+ *  Currently, only streams which have been prepared by LZ4_loadDictHC() should
+ *  be expected to work.
+ *
+ *  Alternatively, the provided dictionary stream pointer may be NULL, in which
+ *  case any existing dictionary stream is unset.
+ *
+ *  A dictionary should only be attached to a stream without any history (i.e.,
+ *  a stream that has just been reset).
+ *
+ *  The dictionary will remain attached to the working stream only for the
+ *  current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the
+ *  dictionary context association from the working stream. The dictionary
+ *  stream (and source buffer) must remain in-place / accessible / unchanged
+ *  through the lifetime of the stream session.
+ */
+LZ4LIB_API void
+LZ4_attach_HC_dictionary(LZ4_streamHC_t* working_stream,
+                   const LZ4_streamHC_t* dictionary_stream);
+
 
 /*^**********************************************
  * !!!!!!   STATIC LINKING ONLY   !!!!!!
@@ -204,18 +234,18 @@ LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, in
 typedef struct LZ4HC_CCtx_internal LZ4HC_CCtx_internal;
 struct LZ4HC_CCtx_internal
 {
-    LZ4_u32   hashTable[LZ4HC_HASHTABLESIZE];
-    LZ4_u16   chainTable[LZ4HC_MAXD];
-    const LZ4_byte* end;       /* next block here to continue on current prefix */
+    LZ4_u32 hashTable[LZ4HC_HASHTABLESIZE];
+    LZ4_u16 chainTable[LZ4HC_MAXD];
+    const LZ4_byte* end;     /* next block here to continue on current prefix */
     const LZ4_byte* prefixStart;  /* Indexes relative to this position */
     const LZ4_byte* dictStart; /* alternate reference for extDict */
-    LZ4_u32   dictLimit;       /* below that point, need extDict */
-    LZ4_u32   lowLimit;        /* below that point, no more dict */
-    LZ4_u32   nextToUpdate;    /* index from which to continue dictionary update */
-    short     compressionLevel;
-    LZ4_i8    favorDecSpeed;   /* favor decompression speed if this flag set,
-                                  otherwise, favor compression ratio */
-    LZ4_i8    dirty;           /* stream has to be fully reset if this flag is set */
+    LZ4_u32 dictLimit;       /* below that point, need extDict */
+    LZ4_u32 lowLimit;        /* below that point, no more history */
+    LZ4_u32 nextToUpdate;    /* index from which to continue dictionary update */
+    short   compressionLevel;
+    LZ4_i8  favorDecSpeed;   /* favor decompression speed if this flag set,
+                                otherwise, favor compression ratio */
+    LZ4_i8  dirty;           /* stream has to be fully reset if this flag is set */
     const LZ4HC_CCtx_internal* dictCtx;
 };
 
@@ -376,35 +406,6 @@ LZ4LIB_STATIC_API int LZ4_compress_HC_extStateHC_fastReset (
     int srcSize, int dstCapacity,
     int compressionLevel);
 
-/*! LZ4_attach_HC_dictionary() :
- *  This is an experimental API that allows for the efficient use of a
- *  static dictionary many times.
- *
- *  Rather than re-loading the dictionary buffer into a working context before
- *  each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a
- *  working LZ4_streamHC_t, this function introduces a no-copy setup mechanism,
- *  in which the working stream references the dictionary stream in-place.
- *
- *  Several assumptions are made about the state of the dictionary stream.
- *  Currently, only streams which have been prepared by LZ4_loadDictHC() should
- *  be expected to work.
- *
- *  Alternatively, the provided dictionary stream pointer may be NULL, in which
- *  case any existing dictionary stream is unset.
- *
- *  A dictionary should only be attached to a stream without any history (i.e.,
- *  a stream that has just been reset).
- *
- *  The dictionary will remain attached to the working stream only for the
- *  current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the
- *  dictionary context association from the working stream. The dictionary
- *  stream (and source buffer) must remain in-place / accessible / unchanged
- *  through the lifetime of the stream session.
- */
-LZ4LIB_STATIC_API void LZ4_attach_HC_dictionary(
-          LZ4_streamHC_t *working_stream,
-    const LZ4_streamHC_t *dictionary_stream);
-
 #if defined (__cplusplus)
 }
 #endif

data/contrib/lz4/lib/xxhash.c

@@ -120,12 +120,12 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcp
 /* *************************************
 *  Compiler Specific Options
 ***************************************/
-#ifdef _MSC_VER    /* Visual Studio */
+#if defined (_MSC_VER) && !defined (__clang__)    /* MSVC */
 #  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
 #  define FORCE_INLINE static __forceinline
 #else
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
+#    if defined (__GNUC__) || defined (__clang__)
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
@@ -213,7 +213,7 @@ static U32 XXH_swap32 (U32 x)
 /* *************************************
 *  Architecture Macros
 ***************************************/
-typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianness;
 
 /* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
 #ifndef XXH_CPU_LITTLE_ENDIAN
@@ -231,7 +231,7 @@ static int XXH_isLittleEndian(void)
 *****************************/
 typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
 
-FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
+FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianness endian, XXH_alignment align)
 {
     if (align==XXH_unaligned)
         return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
@@ -239,7 +239,7 @@ FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_a
         return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
 }
 
-FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
+FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianness endian)
 {
     return XXH_readLE32_align(ptr, endian, XXH_unaligned);
 }
@@ -289,7 +289,7 @@ static U32 XXH32_avalanche(U32 h32)
 
 static U32
 XXH32_finalize(U32 h32, const void* ptr, size_t len,
-                XXH_endianess endian, XXH_alignment align)
+                XXH_endianness endian, XXH_alignment align)
 
 {
     const BYTE* p = (const BYTE*)ptr;
@@ -350,7 +350,7 @@ XXH32_finalize(U32 h32, const void* ptr, size_t len,
 
 FORCE_INLINE U32
 XXH32_endian_align(const void* input, size_t len, U32 seed,
-                    XXH_endianess endian, XXH_alignment align)
+                    XXH_endianness endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* bEnd = p + len;
@@ -398,7 +398,7 @@ XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int s
     XXH32_update(&state, input, len);
     return XXH32_digest(&state);
 #else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
 
     if (XXH_FORCE_ALIGN_CHECK) {
         if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
@@ -449,7 +449,7 @@ XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int s
 
 
 FORCE_INLINE XXH_errorcode
-XXH32_update_endian(XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
+XXH32_update_endian(XXH32_state_t* state, const void* input, size_t len, XXH_endianness endian)
 {
     if (input==NULL)
 #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
@@ -514,7 +514,7 @@ XXH32_update_endian(XXH32_state_t* state, const void* input, size_t len, XXH_end
 
 XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
 {
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
 
     if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
         return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
@@ -524,7 +524,7 @@ XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void*
 
 
 FORCE_INLINE U32
-XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
+XXH32_digest_endian (const XXH32_state_t* state, XXH_endianness endian)
 {
     U32 h32;
 
@@ -545,7 +545,7 @@ XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
 
 XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
 {
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
 
     if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
         return XXH32_digest_endian(state_in, XXH_littleEndian);
@@ -642,7 +642,7 @@ static U64 XXH_swap64 (U64 x)
 }
 #endif
 
-FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
+FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianness endian, XXH_alignment align)
 {
     if (align==XXH_unaligned)
         return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
@@ -650,7 +650,7 @@ FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_a
         return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
 }
 
-FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
+FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianness endian)
 {
     return XXH_readLE64_align(ptr, endian, XXH_unaligned);
 }
@@ -700,7 +700,7 @@ static U64 XXH64_avalanche(U64 h64)
 
 static U64
 XXH64_finalize(U64 h64, const void* ptr, size_t len,
-               XXH_endianess endian, XXH_alignment align)
+               XXH_endianness endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)ptr;
 
@@ -809,7 +809,7 @@ XXH64_finalize(U64 h64, const void* ptr, size_t len,
 
 FORCE_INLINE U64
 XXH64_endian_align(const void* input, size_t len, U64 seed,
-                XXH_endianess endian, XXH_alignment align)
+                XXH_endianness endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* bEnd = p + len;
@@ -861,7 +861,7 @@ XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned
     XXH64_update(&state, input, len);
     return XXH64_digest(&state);
 #else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
 
     if (XXH_FORCE_ALIGN_CHECK) {
         if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
@@ -909,7 +909,7 @@ XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long
 }
 
 FORCE_INLINE XXH_errorcode
-XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
+XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianness endian)
 {
     if (input==NULL)
 #if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
@@ -970,7 +970,7 @@ XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_en
 
 XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
 {
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
 
     if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
         return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
@@ -978,7 +978,7 @@ XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void*
         return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
 }
 
-FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
+FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianness endian)
 {
     U64 h64;
 
@@ -1004,7 +1004,7 @@ FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess
 
 XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
 {
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
 
     if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
         return XXH64_digest_endian(state_in, XXH_littleEndian);

data/contrib/lz4/ossfuzz/decompress_fuzzer.c

@@ -67,7 +67,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
     /* Partial decompression with small prefix. */
     LZ4_decompress_safe_partial_usingDict((char const*)dataAfterDict, dst, size,
                                   dstCapacity, dstCapacity, smallDict, smallDictSize);
-    /* Partial decompression wtih large prefix. */
+    /* Partial decompression with large prefix. */
     LZ4_decompress_safe_partial_usingDict((char const*)dataAfterDict, dst, size,
                                   dstCapacity, dstCapacity, largeDict, largeDictSize);
     free(dst);

data/contrib/lz4/ossfuzz/fuzz_helpers.h

@@ -44,7 +44,7 @@ extern "C" {
           : (fprintf(stderr, "%s: %u: Assertion: `%s' failed. %s\n", __FILE__, \
                      __LINE__, FUZZ_QUOTE(cond), (msg)),                       \
              abort()))
-#define FUZZ_ASSERT(cond) FUZZ_ASSERT_MSG((cond), "");
+#define FUZZ_ASSERT(cond) FUZZ_ASSERT_MSG((cond), "")
 
 #if defined(__GNUC__)
 #define FUZZ_STATIC static __inline __attribute__((unused))

data/ext/blockapi.c

@@ -689,13 +689,13 @@ init_blockencoder(void)
 {
     VALUE cBlockEncoder = rb_define_class_under(extlz4_mLZ4, "BlockEncoder", rb_cObject);
     rb_define_alloc_func(cBlockEncoder, blkenc_alloc);
-    rb_define_method(cBlockEncoder, "initialize", RUBY_METHOD_FUNC(blkenc_init), -1);
-    rb_define_method(cBlockEncoder, "reset", RUBY_METHOD_FUNC(blkenc_reset), -1);
-    rb_define_method(cBlockEncoder, "update", RUBY_METHOD_FUNC(blkenc_update), -1);
-    rb_define_method(cBlockEncoder, "release", RUBY_METHOD_FUNC(blkenc_release), 0);
-    rb_define_method(cBlockEncoder, "predict", RUBY_METHOD_FUNC(blkenc_predict), 0);
-    rb_define_method(cBlockEncoder, "savedict", RUBY_METHOD_FUNC(blkenc_savedict), -1);
-    rb_define_method(cBlockEncoder, "inspect", RUBY_METHOD_FUNC(blkenc_inspect), 0);
+    rb_define_method(cBlockEncoder, "initialize", blkenc_init, -1);
+    rb_define_method(cBlockEncoder, "reset", blkenc_reset, -1);
+    rb_define_method(cBlockEncoder, "update", blkenc_update, -1);
+    rb_define_method(cBlockEncoder, "release", blkenc_release, 0);
+    rb_define_method(cBlockEncoder, "predict", blkenc_predict, 0);
+    rb_define_method(cBlockEncoder, "savedict", blkenc_savedict, -1);
+    rb_define_method(cBlockEncoder, "inspect", blkenc_inspect, 0);
     rb_define_alias(cBlockEncoder, "encode", "update");
     rb_define_alias(cBlockEncoder, "compress", "update");
     rb_define_alias(cBlockEncoder, "free", "release");
@@ -983,10 +983,10 @@ init_blockdecoder(void)
 {
     VALUE cBlockDecoder = rb_define_class_under(extlz4_mLZ4, "BlockDecoder", rb_cObject);
     rb_define_alloc_func(cBlockDecoder, blkdec_alloc);
-    rb_define_method(cBlockDecoder, "initialize", RUBY_METHOD_FUNC(blkdec_init), -1);
-    rb_define_method(cBlockDecoder, "reset", RUBY_METHOD_FUNC(blkdec_reset), -1);
-    rb_define_method(cBlockDecoder, "update", RUBY_METHOD_FUNC(blkdec_update), -1);
-    rb_define_method(cBlockDecoder, "release", RUBY_METHOD_FUNC(blkdec_release), 0);
+    rb_define_method(cBlockDecoder, "initialize", blkdec_init, -1);
+    rb_define_method(cBlockDecoder, "reset", blkdec_reset, -1);
+    rb_define_method(cBlockDecoder, "update", blkdec_update, -1);
+    rb_define_method(cBlockDecoder, "release", blkdec_release, 0);
     rb_define_alias(cBlockDecoder, "decode", "update");
     rb_define_alias(cBlockDecoder, "decompress", "update");
     rb_define_alias(cBlockDecoder, "uncompress", "update");

data/ext/frameapi.c

@@ -737,33 +737,33 @@ extlz4_init_frameapi(void)
 
     VALUE cEncoder = rb_define_class_under(extlz4_mLZ4, "Encoder", rb_cObject);
     rb_define_alloc_func(cEncoder, fenc_alloc);
-    rb_define_method(cEncoder, "initialize", RUBY_METHOD_FUNC(fenc_init), -1);
-    rb_define_method(cEncoder, "write", RUBY_METHOD_FUNC(fenc_write), -1);
-    rb_define_method(cEncoder, "<<", RUBY_METHOD_FUNC(fenc_push), 1);
-    rb_define_method(cEncoder, "flush", RUBY_METHOD_FUNC(fenc_flush), 0);
-    rb_define_method(cEncoder, "close", RUBY_METHOD_FUNC(fenc_close), 0);
+    rb_define_method(cEncoder, "initialize", fenc_init, -1);
+    rb_define_method(cEncoder, "write", fenc_write, -1);
+    rb_define_method(cEncoder, "<<", fenc_push, 1);
+    rb_define_method(cEncoder, "flush", fenc_flush, 0);
+    rb_define_method(cEncoder, "close", fenc_close, 0);
     rb_define_alias(cEncoder, "finish", "close");
-    rb_define_method(cEncoder, "outport", RUBY_METHOD_FUNC(fenc_getoutport), 0);
-    rb_define_method(cEncoder, "outport=", RUBY_METHOD_FUNC(fenc_setoutport), 1);
-    rb_define_method(cEncoder, "prefs_level", RUBY_METHOD_FUNC(fenc_prefs_level), 0);
-    rb_define_method(cEncoder, "prefs_blocksize", RUBY_METHOD_FUNC(fenc_prefs_blocksize), 0);
-    rb_define_method(cEncoder, "prefs_blocklink", RUBY_METHOD_FUNC(fenc_prefs_blocklink), 0);
-    rb_define_method(cEncoder, "prefs_checksum", RUBY_METHOD_FUNC(fenc_prefs_checksum), 0);
-    rb_define_method(cEncoder, "inspect", RUBY_METHOD_FUNC(fenc_inspect), 0);
+    rb_define_method(cEncoder, "outport", fenc_getoutport, 0);
+    rb_define_method(cEncoder, "outport=", fenc_setoutport, 1);
+    rb_define_method(cEncoder, "prefs_level", fenc_prefs_level, 0);
+    rb_define_method(cEncoder, "prefs_blocksize", fenc_prefs_blocksize, 0);
+    rb_define_method(cEncoder, "prefs_blocklink", fenc_prefs_blocklink, 0);
+    rb_define_method(cEncoder, "prefs_checksum", fenc_prefs_checksum, 0);
+    rb_define_method(cEncoder, "inspect", fenc_inspect, 0);
 
     VALUE cDecoder = rb_define_class_under(extlz4_mLZ4, "Decoder", rb_cObject);
     rb_define_alloc_func(cDecoder, fdec_alloc);
-    rb_define_method(cDecoder, "initialize", RUBY_METHOD_FUNC(fdec_init), -1);
-    rb_define_method(cDecoder, "read", RUBY_METHOD_FUNC(fdec_read), -1);
-    rb_define_method(cDecoder, "getc", RUBY_METHOD_FUNC(fdec_getc), 0);
-    rb_define_method(cDecoder, "getbyte", RUBY_METHOD_FUNC(fdec_getbyte), 0);
-    rb_define_method(cDecoder, "close", RUBY_METHOD_FUNC(fdec_close), 0);
+    rb_define_method(cDecoder, "initialize", fdec_init, -1);
+    rb_define_method(cDecoder, "read", fdec_read, -1);
+    rb_define_method(cDecoder, "getc", fdec_getc, 0);
+    rb_define_method(cDecoder, "getbyte", fdec_getbyte, 0);
+    rb_define_method(cDecoder, "close", fdec_close, 0);
     rb_define_alias(cDecoder, "finish", "close");
-    rb_define_method(cDecoder, "eof", RUBY_METHOD_FUNC(fdec_eof), 0);
-    rb_define_method(cDecoder, "inport", RUBY_METHOD_FUNC(fdec_inport), 0);
+    rb_define_method(cDecoder, "eof", fdec_eof, 0);
+    rb_define_method(cDecoder, "inport", fdec_inport, 0);
     rb_define_alias(cDecoder, "eof?", "eof");
-    rb_define_method(cDecoder, "prefs_blocksize", RUBY_METHOD_FUNC(fdec_prefs_blocksize), 0);
-    rb_define_method(cDecoder, "prefs_blocklink", RUBY_METHOD_FUNC(fdec_prefs_blocklink), 0);
-    rb_define_method(cDecoder, "prefs_checksum", RUBY_METHOD_FUNC(fdec_prefs_checksum), 0);
-    rb_define_method(cDecoder, "inspect", RUBY_METHOD_FUNC(fdec_inspect), 0);
+    rb_define_method(cDecoder, "prefs_blocksize", fdec_prefs_blocksize, 0);
+    rb_define_method(cDecoder, "prefs_blocklink", fdec_prefs_blocklink, 0);
+    rb_define_method(cDecoder, "prefs_checksum", fdec_prefs_checksum, 0);
+    rb_define_method(cDecoder, "inspect", fdec_inspect, 0);
 }

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: extlz4
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - dearblue
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,6 +52,8 @@ extra_rdoc_files:
 - contrib/lz4/LICENSE
 - contrib/lz4/README.md
 - contrib/lz4/build/README.md
+- contrib/lz4/build/meson/README.md
+- contrib/lz4/build/visual/README.md
 - contrib/lz4/lib/LICENSE
 - contrib/lz4/lib/README.md
 - ext/blockapi.c
@@ -72,34 +73,21 @@ files:
 - README.md
 - Rakefile
 - bin/extlz4
+- contrib/lz4/CODING_STYLE
 - contrib/lz4/INSTALL
 - contrib/lz4/LICENSE
 - contrib/lz4/Makefile.inc
 - contrib/lz4/NEWS
 - contrib/lz4/README.md
+- contrib/lz4/SECURITY.md
 - contrib/lz4/build/README.md
-- contrib/lz4/build/VS2010/datagen/datagen.vcxproj
-- contrib/lz4/build/VS2010/frametest/frametest.vcxproj
-- contrib/lz4/build/VS2010/fullbench-dll/fullbench-dll.vcxproj
-- contrib/lz4/build/VS2010/fullbench/fullbench.vcxproj
-- contrib/lz4/build/VS2010/fuzzer/fuzzer.vcxproj
-- contrib/lz4/build/VS2010/liblz4-dll/liblz4-dll.rc
-- contrib/lz4/build/VS2010/liblz4-dll/liblz4-dll.vcxproj
-- contrib/lz4/build/VS2010/liblz4/liblz4.vcxproj
-- contrib/lz4/build/VS2010/lz4.sln
-- contrib/lz4/build/VS2010/lz4/lz4.rc
-- contrib/lz4/build/VS2010/lz4/lz4.vcxproj
-- contrib/lz4/build/VS2017/datagen/datagen.vcxproj
-- contrib/lz4/build/VS2017/frametest/frametest.vcxproj
-- contrib/lz4/build/VS2017/fullbench-dll/fullbench-dll.vcxproj
-- contrib/lz4/build/VS2017/fullbench/fullbench.vcxproj
-- contrib/lz4/build/VS2017/fuzzer/fuzzer.vcxproj
-- contrib/lz4/build/VS2017/liblz4-dll/liblz4-dll.rc
-- contrib/lz4/build/VS2017/liblz4-dll/liblz4-dll.vcxproj
-- contrib/lz4/build/VS2017/liblz4/liblz4.vcxproj
-- contrib/lz4/build/VS2017/lz4.sln
-- contrib/lz4/build/VS2017/lz4/lz4.rc
-- contrib/lz4/build/VS2017/lz4/lz4.vcxproj
+- contrib/lz4/build/VS2022/_build.bat
+- contrib/lz4/build/VS2022/_setup.bat
+- contrib/lz4/build/VS2022/_test.bat
+- contrib/lz4/build/VS2022/build-and-test-win32-debug.bat
+- contrib/lz4/build/VS2022/build-and-test-win32-release.bat
+- contrib/lz4/build/VS2022/build-and-test-x64-debug.bat
+- contrib/lz4/build/VS2022/build-and-test-x64-release.bat
 - contrib/lz4/build/VS2022/datagen/datagen.vcxproj
 - contrib/lz4/build/VS2022/frametest/frametest.vcxproj
 - contrib/lz4/build/VS2022/fullbench-dll/fullbench-dll.vcxproj
@@ -109,8 +97,28 @@ files:
 - contrib/lz4/build/VS2022/liblz4-dll/liblz4-dll.vcxproj
 - contrib/lz4/build/VS2022/liblz4/liblz4.vcxproj
 - contrib/lz4/build/VS2022/lz4.sln
+- contrib/lz4/build/VS2022/lz4/lz4.rc
+- contrib/lz4/build/VS2022/lz4/lz4.vcxproj
 - contrib/lz4/build/cmake/CMakeLists.txt
 - contrib/lz4/build/cmake/lz4Config.cmake.in
+- contrib/lz4/build/meson/GetLz4LibraryVersion.py
+- contrib/lz4/build/meson/README.md
+- contrib/lz4/build/meson/meson.build
+- contrib/lz4/build/meson/meson/contrib/gen_manual/meson.build
+- contrib/lz4/build/meson/meson/contrib/meson.build
+- contrib/lz4/build/meson/meson/examples/meson.build
+- contrib/lz4/build/meson/meson/lib/meson.build
+- contrib/lz4/build/meson/meson/meson.build
+- contrib/lz4/build/meson/meson/ossfuzz/meson.build
+- contrib/lz4/build/meson/meson/programs/meson.build
+- contrib/lz4/build/meson/meson/tests/meson.build
+- contrib/lz4/build/meson/meson_options.txt
+- contrib/lz4/build/visual/README.md
+- contrib/lz4/build/visual/generate_solution.cmd
+- contrib/lz4/build/visual/generate_vs2015.cmd
+- contrib/lz4/build/visual/generate_vs2017.cmd
+- contrib/lz4/build/visual/generate_vs2019.cmd
+- contrib/lz4/build/visual/generate_vs2022.cmd
 - contrib/lz4/lib/LICENSE
 - contrib/lz4/lib/README.md
 - contrib/lz4/lib/liblz4-dll.rc.in
@@ -168,7 +176,6 @@ homepage: https://github.com/dearblue/ruby-extlz4
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
 rdoc_options:
 - "--charset"
 - UTF-8
@@ -187,8 +194,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
-signing_key:
+rubygems_version: 3.6.8
 specification_version: 4
 summary: ruby bindings for LZ4
 test_files: []