sereal 0.0.3 → 0.0.4

data/ext/sereal/lz4hc.h

@@ -0,0 +1,111 @@
+/*
+   LZ4 HC - High Compression Mode of LZ4
+   Header File
+   Copyright (C) 2011-2013, 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 :
+   - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
+   - LZ4 source repository : http://code.google.com/p/lz4/
+*/
+#pragma once
+
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+int LZ4_compressHC (const char* source, char* dest, int inputSize);
+/*
+LZ4_compressHC :
+    return : the number of bytes in compressed buffer dest
+             or 0 if compression fails.
+    note : destination buffer must be already allocated. 
+        To avoid any problem, size it to handle worst cases situations (input data not compressible)
+        Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
+*/
+
+int LZ4_compressHC_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
+/*
+LZ4_compress_limitedOutput() :
+    Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
+    If it cannot achieve it, compression will stop, and result of the function will be zero.
+    This function never writes outside of provided output buffer.
+
+    inputSize  : Max supported value is 1 GB
+    maxOutputSize : is maximum allowed size into the destination buffer (which must be already allocated)
+    return : the number of output bytes written in buffer 'dest'
+             or 0 if compression fails.
+*/
+
+
+/* Note :
+Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license)
+*/
+
+
+/* Advanced Functions */
+
+void* LZ4_createHC (const char* inputBuffer);
+int   LZ4_compressHC_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize);
+int   LZ4_compressHC_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize);
+char* LZ4_slideInputBufferHC (void* LZ4HC_Data);
+int   LZ4_freeHC (void* LZ4HC_Data);
+
+/* 
+These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks.
+In order to achieve this, it is necessary to start creating the LZ4HC Data Structure, thanks to the function :
+
+void* LZ4_createHC (const char* inputBuffer);
+The result of the function is the (void*) pointer on the LZ4HC Data Structure.
+This pointer will be needed in all other functions.
+If the pointer returned is NULL, then the allocation has failed, and compression must be aborted.
+The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer.
+The input buffer must be already allocated, and size at least 192KB.
+'inputBuffer' will also be the 'const char* source' of the first block.
+
+All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'.
+To compress each block, use either LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue().
+Their behavior are identical to LZ4_compressHC() or LZ4_compressHC_limitedOutput(), 
+but require the LZ4HC Data Structure as their first argument, and check that each block starts right after the previous one.
+If next block does not begin immediately after the previous one, the compression will fail (return 0).
+
+When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to : 
+char* LZ4_slideInputBufferHC(void* LZ4HC_Data);
+must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer.
+Note that, for this function to work properly, minimum size of an input buffer must be 192KB.
+==> The memory position where the next input data block must start is provided as the result of the function.
+
+Compression can then resume, using LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(), as usual.
+
+When compression is completed, a call to LZ4_freeHC() will release the memory used by the LZ4HC Data Structure.
+*/
+
+
+#if defined (__cplusplus)
+}
+#endif

data/ext/sereal/proto.h

@@ -6,8 +6,10 @@
 #define SRL_PROTOCOL_VERSION_MASK       ( ( 1 << SRL_PROTOCOL_VERSION_BITS ) - 1 )
 
 #define SRL_PROTOCOL_ENCODING_MASK      ( ~SRL_PROTOCOL_VERSION_MASK )
-#define SRL_PROTOCOL_ENCODING_RAW       ( 0 << SRL_PROTOCOL_VERSION_BITS )
-#define SRL_PROTOCOL_ENCODING_SNAPPY    ( 1 << SRL_PROTOCOL_VERSION_BITS )
+#define SRL_PROTOCOL_ENCODING_RAW         ( 0 << SRL_PROTOCOL_VERSION_BITS )
+#define SRL_PROTOCOL_ENCODING_SNAPPY      ( 1 << SRL_PROTOCOL_VERSION_BITS )
+#define SRL_PROTOCOL_ENCODING_SNAPPY_INCR ( 2 << SRL_PROTOCOL_VERSION_BITS )
+#define SRL_PROTOCOL_ENCODING_LZ4_INCR    ( 3 << SRL_PROTOCOL_VERSION_BITS )
 
 #define SRL_HDR_POS             ((char)0)       /* small positive integer - value in low 4 bits (identity) */
 #define SRL_HDR_POS_LOW         ((char)0)       /* small positive integer - value in low 4 bits (identity) */

data/ext/sereal/sereal.c

@@ -3,10 +3,40 @@
 
 VALUE Sereal = Qnil;
 void Init_sereal();
+
+/*
+ * Encode/Decode object using Sereal binary protocol:
+ * https://github.com/Sereal/Sereal/blob/master/sereal_spec.pod
+ *
+ *   Sereal.encode(object) -> serialized blob
+ *   Sereal.encode(object,Sereal::LZ4) -> LZ4 compressed blob
+ *   Sereal.encode(object,Sereal::LZ4HC) -> LZ4HC compressed blob
+ *   Sereal.encode(object,Sereal::SNAPPY_INCR) -> snappy compressed blob
+ *   Sereal.encode(object,Sereal::SNAPPY) -> snappy compressed blob
+ *
+ * LZ4 LZ4HC and SNAPPY_INCR can be appended into one output and then the
+ * decoder will know what to do.
+ *
+ *   Sereal.decode(blob) - returns the decoded object
+ *   
+ * If the blob contains multiple compressed(with LZ4* or SNAPPY_INCR) 
+ * sub-blobs you should call it with:
+ *       
+ *    Sereal.decode(blob) do |decoded|
+ *       # do something with the decoded object 
+ *    end
+ * otherwise only the first decoded object will be returned
+ *
+ */
 void Init_sereal() {
         Sereal = rb_define_class("Sereal", rb_cObject);
         rb_define_singleton_method(Sereal, "encode", method_sereal_encode, -2);
         rb_define_singleton_method(Sereal, "decode", method_sereal_decode, -2);
+        rb_define_const(Sereal, "SNAPPY",INT2NUM(__SNAPPY));
+        rb_define_const(Sereal, "SNAPPY_INCR",INT2NUM(__SNAPPY_INCR));
+        rb_define_const(Sereal, "RAW",INT2NUM(__RAW));
+        rb_define_const(Sereal, "LZ4",INT2NUM(__LZ4_INCR));
+        rb_define_const(Sereal, "LZ4HC",INT2NUM(__LZ4HC_INCR));
         s_init_writers();
 }
 

data/ext/sereal/sereal.h

@@ -40,7 +40,13 @@ typedef struct _track_entry     track_t;
 	#define MULTILINE RE_OPTION_MULTILINE
 	#define EXTENDED RE_OPTION_EXTENDED
 #endif
-#define FLAG_SAFE 1
+#define s_raise(what,ex,arg...)         \
+do {                                    \
+    s_destroy(what);                    \
+    rb_raise(ex,##arg);                 \
+} while(0);
+
+#define FLAG_NOT_MINE 1
 struct _sereal {
         u8 *data;
         u32 size;
@@ -70,4 +76,10 @@ do {                                                              \
 #define rb_sym_to_s(object) rb_funcall(object,rb_intern("to_s"),0)
 #endif
 
+#define __RAW           0
+#define __SNAPPY        1
+#define __SNAPPY_INCR   2
+#define __LZ4_INCR      3
+#define __LZ4HC_INCR    4
+
 #endif

data/ext/sereal/snappy/csnappy_compat.h

@@ -0,0 +1,16 @@
+#ifndef CSNAPPY_COMPAT_H
+
+/* This file was added to Sereal to attempt some MSVC compatibility,
+ * but is at best a band-aid. And done without a lot of experience
+ * in whatever subset of C99 MSVC supports.
+ */
+
+#ifndef INLINE
+#   if defined(_MSC_VER)
+#     define INLINE __inline
+#   else
+#     define INLINE inline
+#   endif
+#endif
+
+#endif

data/ext/sereal/snappy/csnappy_compress.c

@@ -30,6 +30,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 File modified for the Linux Kernel by
 Zeev Tarantov <zeev.tarantov@gmail.com>
+
+File modified for Sereal by
+Steffen Mueller <smueller@cpan.org>
 */
 
 #include "csnappy_internal.h"
@@ -40,7 +43,7 @@ Zeev Tarantov <zeev.tarantov@gmail.com>
 #include "csnappy.h"
 
 
-static inline char*
+static INLINE char*
 encode_varint32(char *sptr, uint32_t v)
 {
 	uint8_t* ptr = (uint8_t *)sptr;
@@ -222,12 +225,12 @@ the_end:
  * input. Of course, it doesn't hurt if the hash function is reasonably fast
  * either, as it gets called a lot.
  */
-static inline uint32_t HashBytes(uint32_t bytes, int shift)
+static INLINE uint32_t HashBytes(uint32_t bytes, int shift)
 {
 	uint32_t kMul = 0x1e35a7bd;
 	return (bytes * kMul) >> shift;
 }
-static inline uint32_t Hash(const char *p, int shift)
+static INLINE uint32_t Hash(const char *p, int shift)
 {
 	return HashBytes(UNALIGNED_LOAD32(p), shift);
 }
@@ -247,7 +250,7 @@ static inline uint32_t Hash(const char *p, int shift)
  * x86_64 is little endian.
  */
 #if defined(__x86_64__)
-static inline int
+static INLINE int
 FindMatchLength(const char *s1, const char *s2, const char *s2_limit)
 {
 	uint64_t x;
@@ -291,7 +294,7 @@ FindMatchLength(const char *s1, const char *s2, const char *s2_limit)
 	return matched;
 }
 #else /* !defined(__x86_64__) */
-static inline int
+static INLINE int
 FindMatchLength(const char *s1, const char *s2, const char *s2_limit)
 {
 	/* Implementation based on the x86-64 version, above. */
@@ -326,7 +329,7 @@ FindMatchLength(const char *s1, const char *s2, const char *s2_limit)
 #endif /* !defined(__x86_64__) */
 
 
-static inline char*
+static INLINE char*
 EmitLiteral(char *op, const char *literal, int len, int allow_fast_path)
 {
 	int n = len - 1; /* Zero-length literals are disallowed */
@@ -367,7 +370,7 @@ EmitLiteral(char *op, const char *literal, int len, int allow_fast_path)
 	return op + len;
 }
 
-static inline char*
+static INLINE char*
 EmitCopyLessThan64(char *op, int offset, int len)
 {
 	DCHECK_LE(len, 64);
@@ -377,19 +380,19 @@ EmitCopyLessThan64(char *op, int offset, int len)
 	if ((len < 12) && (offset < 2048)) {
 		int len_minus_4 = len - 4;
 		DCHECK_LT(len_minus_4, 8); /* Must fit in 3 bits */
-		*op++ = COPY_1_BYTE_OFFSET   |
-			((len_minus_4) << 2) |
+		*op++ = COPY_1_BYTE_OFFSET   +
+			((len_minus_4) << 2) +
 			((offset >> 8) << 5);
 		*op++ = offset & 0xff;
 	} else {
-		*op++ = COPY_2_BYTE_OFFSET | ((len-1) << 2);
+		*op++ = COPY_2_BYTE_OFFSET + ((len-1) << 2);
 		put_unaligned_le16(offset, op);
 		op += 2;
 	}
 	return op;
 }
 
-static inline char*
+static INLINE char*
 EmitCopy(char *op, int offset, int len)
 {
 	/* Emit 64 byte copies but make sure to keep at least four bytes
@@ -420,7 +423,7 @@ empirically found that overlapping loads such as
 are slower than UNALIGNED_LOAD64(p) followed by shifts and casts to uint32.
 
 We have different versions for 64- and 32-bit; ideally we would avoid the
-two functions and just inline the UNALIGNED_LOAD64 call into
+two functions and just INLINE the UNALIGNED_LOAD64 call into
 GetUint32AtOffset, but GCC (at least not as of 4.6) is seemingly not clever
 enough to avoid loading the value multiple times then. For 64-bit, the load
 is done when GetEightBytesAt() is called, whereas for 32-bit, the load is
@@ -431,11 +434,11 @@ done at GetUint32AtOffset() time.
 
 typedef uint64_t EightBytesReference;
 
-static inline EightBytesReference GetEightBytesAt(const char* ptr) {
+static INLINE EightBytesReference GetEightBytesAt(const char* ptr) {
 	return UNALIGNED_LOAD64(ptr);
 }
 
-static inline uint32_t GetUint32AtOffset(uint64_t v, int offset) {
+static INLINE uint32_t GetUint32AtOffset(uint64_t v, int offset) {
 	DCHECK_GE(offset, 0);
 	DCHECK_LE(offset, 4);
 #ifdef __LITTLE_ENDIAN
@@ -449,11 +452,11 @@ static inline uint32_t GetUint32AtOffset(uint64_t v, int offset) {
 
 typedef const char* EightBytesReference;
 
-static inline EightBytesReference GetEightBytesAt(const char* ptr) {
+static INLINE EightBytesReference GetEightBytesAt(const char* ptr) {
 	return ptr;
 }
 
-static inline uint32_t GetUint32AtOffset(const char* v, int offset) {
+static INLINE uint32_t GetUint32AtOffset(const char* v, int offset) {
 	DCHECK_GE(offset, 0);
 	DCHECK_LE(offset, 4);
 	return UNALIGNED_LOAD32(v + offset);

data/ext/sereal/snappy/csnappy_decompress.c

@@ -30,6 +30,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 File modified for the Linux Kernel by
 Zeev Tarantov <zeev.tarantov@gmail.com>
+
+File modified for Sereal by
+Steffen Mueller <smueller@cpan.org>
 */
 
 #include "csnappy_internal.h"
@@ -194,7 +197,7 @@ static const uint16_t char_table[256] = {
  * Note that this does not match the semantics of either memcpy()
  * or memmove().
  */
-static inline void IncrementalCopy(const char *src, char *op, int len)
+static INLINE void IncrementalCopy(const char *src, char *op, int len)
 {
 	DCHECK_GT(len, 0);
 	do {
@@ -235,7 +238,7 @@ static inline void IncrementalCopy(const char *src, char *op, int len)
  * position 1. Thus, ten excess bytes.
  */
 static const int kMaxIncrementCopyOverflow = 10;
-static inline void IncrementalCopyFastPath(const char *src, char *op, int len)
+static INLINE void IncrementalCopyFastPath(const char *src, char *op, int len)
 {
 	while (op - src < 8) {
 		UnalignedCopy64(src, op);
@@ -258,7 +261,7 @@ struct SnappyArrayWriter {
 	char *op_limit;
 };
 
-static inline int
+static INLINE int
 SAW__AppendFastPath(struct SnappyArrayWriter *this,
 		    const char *ip, uint32_t len)
 {
@@ -276,7 +279,7 @@ SAW__AppendFastPath(struct SnappyArrayWriter *this,
 	return CSNAPPY_E_OK;
 }
 
-static inline int
+static INLINE int
 SAW__Append(struct SnappyArrayWriter *this,
 	    const char *ip, uint32_t len)
 {
@@ -289,7 +292,7 @@ SAW__Append(struct SnappyArrayWriter *this,
 	return CSNAPPY_E_OK;
 }
 
-static inline int
+static INLINE int
 SAW__AppendFromSelf(struct SnappyArrayWriter *this,
 		    uint32_t offset, uint32_t len)
 {

data/ext/sereal/snappy/csnappy_internal.h

@@ -31,11 +31,16 @@ Various stubs for the open-source version of Snappy.
 
 File modified for the Linux Kernel by
 Zeev Tarantov <zeev.tarantov@gmail.com>
+
+File modified for Sereal by
+Steffen Mueller <smueller@cpan.org>
 */
 
 #ifndef CSNAPPY_INTERNAL_H_
 #define CSNAPPY_INTERNAL_H_
 
+#include "csnappy_compat.h"
+
 #ifndef __KERNEL__
 #include "csnappy_internal_userspace.h"
 #include <string.h>
@@ -77,11 +82,15 @@ Zeev Tarantov <zeev.tarantov@gmail.com>
 
 #endif /* __KERNEL__ */
 
+#if (!defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)) || ! defined(__BYTE_ORDER)
+#  error either __LITTLE_ENDIAN or __BIG_ENDIAN, plus __BYTE_ORDER must be defined
+#endif
+
 #define ARCH_ARM_HAVE_UNALIGNED \
     defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) || defined(__ARMV6__) || \
     defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__)
 
-static inline void UnalignedCopy64(const void *src, void *dst) {
+static INLINE void UnalignedCopy64(const void *src, void *dst) {
 #if defined(__i386__) || defined(__x86_64__) || defined(__powerpc__) || ARCH_ARM_HAVE_UNALIGNED
   if ((sizeof(void *) == 8) || (sizeof(long) == 8)) {
     UNALIGNED_STORE64(dst, UNALIGNED_LOAD64(src));
@@ -110,7 +119,7 @@ static inline void UnalignedCopy64(const void *src, void *dst) {
 
 #if defined(__arm__)
   #if ARCH_ARM_HAVE_UNALIGNED
-     static inline uint32_t get_unaligned_le(const void *p, uint32_t n)
+     static INLINE uint32_t get_unaligned_le(const void *p, uint32_t n)
      {
        uint32_t wordmask = (1U << (8 * n)) - 1;
        return get_unaligned_le32(p) & wordmask;
@@ -120,7 +129,7 @@ static inline void UnalignedCopy64(const void *src, void *dst) {
      #define get_unaligned_le get_unaligned_le_armv5
   #endif
 #else
-  static inline uint32_t get_unaligned_le(const void *p, uint32_t n)
+  static INLINE uint32_t get_unaligned_le(const void *p, uint32_t n)
   {
     /* Mapping from i in range [0,4] to a mask to extract the bottom 8*i bits */
     static const uint32_t wordmask[] = {

data/ext/sereal/snappy/csnappy_internal_userspace.h

@@ -31,16 +31,43 @@ Various stubs for the open-source version of Snappy.
 
 File modified by
 Zeev Tarantov <zeev.tarantov@gmail.com>
+
+File modified for Sereal by
+Steffen Mueller <smueller@cpan.org>
 */
 
 #ifndef CSNAPPY_INTERNAL_USERSPACE_H_
 #define CSNAPPY_INTERNAL_USERSPACE_H_
 
-#if defined(_MSC_VER) && (_MSC_VER <= 1300)
+/*note the original version of this file checked for MS version, but MS will *never* support
+ * anything but C89, so the version check is bogus. */
+#if defined(_MSC_VER)
 typedef unsigned __int8  uint8_t;
 typedef unsigned __int16 uint16_t;
 typedef unsigned __int32 uint32_t;
 typedef unsigned __int64 uint64_t;
+typedef __int32 int32_t; /* Sereal specific change, see csnappy_decompress.c(271) : error C2065: 'int32_t' : undeclared identifier */
+/* the following define is Sereal specific, as MS C89 compilers do not know about "inline" */
+#define inline __inline
+#ifdef _M_X64
+#  define __x86_64__
+#  define __x86_64
+#  define __amd64__
+#  define __amd64
+#endif
+#ifdef _M_IX86
+#  define __i386__
+#  define __i386
+#  define i386
+#  define _X86_
+#endif
+#ifdef _M_IA64
+#  define __ia64__
+#  define __ia64
+#  define __IA64__
+#  define __itanium__
+#endif
+
 #else
 #include <stdint.h>
 #endif
@@ -70,6 +97,8 @@ typedef unsigned __int64 uint64_t;
 #define DCHECK(cond)
 #endif
 
+#include "csnappy_compat.h"
+
 /*
 Uses code from http://code.google.com/p/exfat/source/browse/trunk/libexfat/byteorder.h
 with 3-clause BSD license instead of GPL, with permission from:
@@ -82,6 +111,9 @@ Albert Lee
 #define bswap_16(x) _byteswap_ushort(x)
 #define bswap_32(x) _byteswap_ulong(x)
 #define bswap_64(x) _byteswap_uint64(x)
+#define __BIG_ENDIAN	4321
+#define __LITTLE_ENDIAN	1234
+#define __BYTE_ORDER	LITTLE_ENDIAN
 
 #elif defined(__GLIBC__) || defined(__ANDROID__) || defined(__CYGWIN__)
 
@@ -99,7 +131,7 @@ Albert Lee
 #define __LITTLE_ENDIAN LITTLE_ENDIAN
 #define __BIG_ENDIAN BIG_ENDIAN
 
-#elif defined(__FreeBSD__) || defined(__DragonFlyBSD__) || defined(__NetBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__)
 
 #include <sys/endian.h>
 #define bswap_16(x) bswap16(x)
@@ -133,6 +165,12 @@ Albert Lee
 #define __BYTE_ORDER __BIG_ENDIAN
 #endif
 
+#elif defined(__MINGW32__)
+#include <sys/param.h>
+#define __BYTE_ORDER BYTE_ORDER
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#define __BIG_ENDIAN BIG_ENDIAN
+
 #endif
 
 
@@ -169,13 +207,13 @@ Albert Lee
 struct una_u64 { uint64_t x; };
 #pragma pack()
 
-static inline uint64_t UNALIGNED_LOAD64(const void *p)
+static INLINE uint64_t UNALIGNED_LOAD64(const void *p)
 {
 	const struct una_u64 *ptr = (const struct una_u64 *)p;
 	return ptr->x;
 }
 
-static inline void UNALIGNED_STORE64(void *p, uint64_t v)
+static INLINE void UNALIGNED_STORE64(void *p, uint64_t v)
 {
 	struct una_u64 *ptr = (struct una_u64 *)p;
 	ptr->x = v;
@@ -189,37 +227,37 @@ struct una_u32 { uint32_t x; };
 struct una_u64 { uint64_t x; };
 #pragma pack()
 
-static inline uint16_t UNALIGNED_LOAD16(const void *p)
+static INLINE uint16_t UNALIGNED_LOAD16(const void *p)
 {
 	const struct una_u16 *ptr = (const struct una_u16 *)p;
 	return ptr->x;
 }
 
-static inline uint32_t UNALIGNED_LOAD32(const void *p)
+static INLINE uint32_t UNALIGNED_LOAD32(const void *p)
 {
 	const struct una_u32 *ptr = (const struct una_u32 *)p;
 	return ptr->x;
 }
 
-static inline uint64_t UNALIGNED_LOAD64(const void *p)
+static INLINE uint64_t UNALIGNED_LOAD64(const void *p)
 {
 	const struct una_u64 *ptr = (const struct una_u64 *)p;
 	return ptr->x;
 }
 
-static inline void UNALIGNED_STORE16(void *p, uint16_t v)
+static INLINE void UNALIGNED_STORE16(void *p, uint16_t v)
 {
 	struct una_u16 *ptr = (struct una_u16 *)p;
 	ptr->x = v;
 }
 
-static inline void UNALIGNED_STORE32(void *p, uint32_t v)
+static INLINE void UNALIGNED_STORE32(void *p, uint32_t v)
 {
 	struct una_u32 *ptr = (struct una_u32 *)p;
 	ptr->x = v;
 }
 
-static inline void UNALIGNED_STORE64(void *p, uint64_t v)
+static INLINE void UNALIGNED_STORE64(void *p, uint64_t v)
 {
 	struct una_u64 *ptr = (struct una_u64 *)p;
 	ptr->x = v;
@@ -232,21 +270,21 @@ static inline void UNALIGNED_STORE64(void *p, uint64_t v)
 #define get_unaligned_le32(p)           UNALIGNED_LOAD32(p)
 #define put_unaligned_le16(v, p)        UNALIGNED_STORE16(p, v)
 #elif __BYTE_ORDER == __BIG_ENDIAN
-static inline uint32_t get_unaligned_le32(const void *p)
+static INLINE uint32_t get_unaligned_le32(const void *p)
 {
   return bswap_32(UNALIGNED_LOAD32(p));
 }
-static inline void put_unaligned_le16(uint16_t val, void *p)
+static INLINE void put_unaligned_le16(uint16_t val, void *p)
 {
   UNALIGNED_STORE16(p, bswap_16(val));
 }
 #else
-static inline uint32_t get_unaligned_le32(const void *p)
+static INLINE uint32_t get_unaligned_le32(const void *p)
 {
   const uint8_t *b = (const uint8_t *)p;
   return b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
 }
-static inline void put_unaligned_le16(uint16_t val, void *p)
+static INLINE void put_unaligned_le16(uint16_t val, void *p)
 {
   uint8_t *b = (uint8_t *)p;
   b[0] = val & 255;
@@ -257,19 +295,19 @@ static inline void put_unaligned_le16(uint16_t val, void *p)
 
 #if defined(HAVE_BUILTIN_CTZ)
 
-static inline int FindLSBSetNonZero(uint32_t n)
+static INLINE int FindLSBSetNonZero(uint32_t n)
 {
 	return __builtin_ctz(n);
 }
 
-static inline int FindLSBSetNonZero64(uint64_t n)
+static INLINE int FindLSBSetNonZero64(uint64_t n)
 {
 	return __builtin_ctzll(n);
 }
 
 #else /* Portable versions. */
 
-static inline int FindLSBSetNonZero(uint32_t n)
+static INLINE int FindLSBSetNonZero(uint32_t n)
 {
 	int rc = 31, i, shift;
 	uint32_t x;
@@ -285,7 +323,7 @@ static inline int FindLSBSetNonZero(uint32_t n)
 }
 
 /* FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero(). */
-static inline int FindLSBSetNonZero64(uint64_t n)
+static INLINE int FindLSBSetNonZero64(uint64_t n)
 {
 	const uint32_t bottombits = (uint32_t)n;
 	if (bottombits == 0) {