RubyGems - crc-turbo - Versions diffs - 0.1-x86-mingw32 → 0.2-x86-mingw32 - Mend

crc-turbo 0.1-x86-mingw32 → 0.2-x86-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 263718966306d1579a8e54c12ffcc39ceee33a13
-  data.tar.gz: 57ce8a4a8f07392f847bc472f82af1c0aa322d62
+  metadata.gz: 019207cb17862096bb83b5ab102ca7fc5ac1d372
+  data.tar.gz: 025ab1256a46655f1ed2cc75b4d44b868474aafc
 SHA512:
-  metadata.gz: e60394e399127f22937feec6e670d6e7c53563e7b72b041c03a5d5fec2b7ea8cae2a73a2f3165a9a2d97b1f68fd9c3e37ba48d1da2ee5b4d8192bc9d34259222
-  data.tar.gz: 4fed18b1b53b477b85c9ebd032d40746210f1738e759cc79296d2738567dacbb9ca722f39aa8e562ed5001d6556ad04cd6f26540ff67b87031e37d1b179ca02d
+  metadata.gz: 9213fc2651da32478981d4bac664e13b6810bd5375aec627027bcb50b5b769da27d8dbd0a89e4f4eb3fedf9522d6519d603b61a9c9d2af3f4e7570f72c512012
+  data.tar.gz: 882bd8bca35dbcdde5f2f50bd4616a9d2b1f192d183483bb8609154f12b16f64d8346da34871e38b919cb978fe2d101642a514bbe82d7706f873e1d6ec3d67a5

data/HISTORY.ja.md ADDED Viewed

@@ -0,0 +1,14 @@
+This document is written in Japanese.
+# crc-turbo for ruby の更新履歴
+## crc-0.2 (平成28年5月15日 (日))
+  * \[FIX\] CRC::Generator#polynomial メソッドが間違った値を返していた問題を修正
+  * CRC::Utils.bitreflect128 メソッドの実装
+  * CRC::BasicCRC#update メソッドの実装を slice-by-eight から slice-by-16 へと変更
+  * CRC ルックアップテーブル領域確保の時機を初回計算時の直前とするように改善
+## crc-0.1 (平成28年5月8日 (日))
+初版

data/README.md CHANGED Viewed

@@ -3,24 +3,24 @@
 This is a C extention for "crc" gem library.
-Just install this, and "require 'crc'". Additional other work is not required.
+Just install this, and to do "require 'crc'" only. Additional other work is not required.
-## SUMMARY
+## Summary
   * package name: crc-turbo
   * author: dearblue (mailto:dearblue@users.osdn.me)
   * report issue to: <https://osdn.jp/projects/rutsubo/ticket/>
   * how to install: ``gem install crc-turbo``
-  * version: 0.1
+  * version: 0.2
   * release quality: thechnical preview
-  * licensing: BSD-2-Clause
-  * dependency gems: crc (<https://rubygems/gems/crc>)
+  * licensing: BSD-2-Clause<br>any parts are under Creative Commons License Zero (CC0 / Public Domain).
+  * dependency gems: crc-0.2 (<https://rubygems/gems/crc>)
   * dependency external c libraries: none
   * bundled external c libraries: none
-## HOW TO USAGE
+## How to usage
 First, install on your system.
@@ -34,19 +34,21 @@ And, to do ``require "crc"``.
 ``` shell:shell
 $ ruby -r crc -e 'puts $".grep(/crc/)'
-/usr/local/lib/ruby/gems/2.3/gems/crc-turbo-0.1/lib/crc/_turbo.so
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc/_modules.rb
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-turbo-0.2/lib/crc/2.3/_turbo.so
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_modules.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_combine.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc.rb
 $
 ```
-If you want not use crc-turbo, set ``RUBY_CRC_NOFAST`` enviroment variable.
+If you want to not use crc-turbo, set ``RUBY_CRC_NOFAST`` enviroment variable.
 ``` shell:shell
-$ RUBY_CRC_NOFAST=1
+$ export RUBY_CRC_NOFAST=1
 $ ruby -r crc -e 'puts $".grep(/crc/)'
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc/_byruby.rb
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc/_modules.rb
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_byruby.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_modules.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_combine.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc.rb
 $
 ```

data/ext/crc/crc_imps.h ADDED Viewed

@@ -0,0 +1,264 @@
+/*
+ * author:: dearblue <dearblue@users.osdn.me>
+ * license:: Creative Commons License Zero (CC0 / Public Domain)
+ *
+ * This is a general CRC generator.
+ *
+ * It's used slice-by-16 algorithm with byte-order free and byte-alignment free.
+ * This is based on the Intel's slice-by-eight algorithm.
+ *
+ * Worst point is need more memory!
+ *
+ * reference:
+ * * https://sourceforge.net/projects/slicing-by-8/
+ * * xz-utils
+ *      * http://tukaani.org/xz/
+ *      * xz-5.2.2/src/liblzma/check/crc32_fast.c
+ *      * xz-5.2.2/src/liblzma/check/crc32_tablegen.c
+ */
+#if     !defined(CRC_TYPE) || \
+        !defined(CRC_BITREFLECT) || \
+        !defined(CRC_BUILD_TABLES) || \
+        !defined(CRC_UPDATE) || \
+        !defined(CRC_BUILD_REFLECT_TABLES) || \
+        !defined(CRC_REFLECT_UPDATE)
+#   error not defined CRC_TYPE, CRC_BITREFLECT, CRC_BUILD_TABLES, CRC_UPDATE, CRC_BUILD_REFLECT_TABLES or CRC_REFLECT_UPDATE before include this file
+#endif
+#ifndef CRC_INLINE
+#   define CRC_INLINE
+#endif
+/*
+ * [bitsize]
+ *      CRC bit-size. 32 for CRC-32, 7 for CRC-7, and so on.
+ *
+ * [table]
+ *      lookup table. total byte size is sizeof(CRC_TYPE[slicesize][256]).
+ *
+ *      16384 for CRC-32:slicesize=16.
+ *
+ * [poly]
+ *      polynomial. not reflected.
+ *
+ * [slicesize]
+ *      table slice size.
+ *
+ *      1 for standard lookup-table, 4 for slice-by-four, 16 for slice-by-16, and so on.
+ */
+static CRC_INLINE void
+CRC_BUILD_TABLES(int bitsize, CRC_TYPE table[][256], CRC_TYPE poly, int slicesize)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    CRC_TYPE (*t)[256] = table;
+    int s, b, i;
+    poly <<= (typebits - bitsize);
+    for (s = 0; s < slicesize; s ++) {
+        CRC_TYPE *p = *t;
+        for (b = 0; b < 256; b ++) {
+            CRC_TYPE r = (s == 0) ? ((CRC_TYPE)b << (typebits - 8)) : t[-1][b];
+            for (i = 0; i < 8; i ++) {
+                r = (r << 1) ^ (poly & -(r >> (typebits - 1)));
+            }
+            *p ++ = r;
+        }
+        t ++;
+    }
+}
+/*
+ * [bitsize]
+ *      CRC bit-size. 32 for CRC-32, 7 for CRC-7, and so on.
+ *
+ * [table]
+ *      lookup table. total byte size is sizeof(CRC_TYPE[slicesize][256]).
+ *
+ *      16384 for CRC-32:slicesize=16.
+ *
+ * [poly]
+ *      polynomial. not reflected.
+ *
+ * [slicesize]
+ *      table slice size.
+ *
+ *      1 for standard lookup-table, 4 for slice-by-four, 16 for slice-by-16, and so on.
+ */
+static CRC_INLINE void
+CRC_BUILD_REFLECT_TABLES(int bitsize, CRC_TYPE table[][256], CRC_TYPE poly, int slicesize)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    CRC_TYPE (*t)[256] = table;
+    poly = CRC_BITREFLECT(poly << (typebits - bitsize));
+    int s, b;
+    for (s = 0; s < slicesize; s ++) {
+        CRC_TYPE *p = *t;
+        for (b = 0; b < 256; b ++) {
+            int i;
+            CRC_TYPE r = (s == 0) ? b : t[-1][b];
+            for (i = 0; i < 8; i ++) {
+                r = (r >> 1) ^ (poly & -(r & 1));
+            }
+            *p ++ = r;
+        }
+        t ++;
+    }
+}
+static CRC_TYPE
+CRC_UPDATE(int bitsize, const CRC_TYPE table[16][256],
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    const char *pp16 = ((pp - p) & ~0x0f) + p;
+    state <<= typebits - bitsize;
+    for (; p < pp16; p += 16) {
+        state = table[15][(uint8_t)p[ 0] ^                   (uint8_t)(state >> (typebits -   8))     ] ^
+                table[14][(uint8_t)p[ 1] ^ (typebits >   8 ? (uint8_t)(state >> (typebits -  16)) : 0)] ^
+                table[13][(uint8_t)p[ 2] ^ (typebits >  16 ? (uint8_t)(state >> (typebits -  24)) : 0)] ^
+                table[12][(uint8_t)p[ 3] ^ (typebits >  24 ? (uint8_t)(state >> (typebits -  32)) : 0)] ^
+                table[11][(uint8_t)p[ 4] ^ (typebits >  32 ? (uint8_t)(state >> (typebits -  40)) : 0)] ^
+                table[10][(uint8_t)p[ 5] ^ (typebits >  40 ? (uint8_t)(state >> (typebits -  48)) : 0)] ^
+                table[ 9][(uint8_t)p[ 6] ^ (typebits >  48 ? (uint8_t)(state >> (typebits -  56)) : 0)] ^
+                table[ 8][(uint8_t)p[ 7] ^ (typebits >  56 ? (uint8_t)(state >> (typebits -  64)) : 0)] ^
+                table[ 7][(uint8_t)p[ 8] ^ (typebits >  64 ? (uint8_t)(state >> (typebits -  72)) : 0)] ^
+                table[ 6][(uint8_t)p[ 9] ^ (typebits >  72 ? (uint8_t)(state >> (typebits -  80)) : 0)] ^
+                table[ 5][(uint8_t)p[10] ^ (typebits >  80 ? (uint8_t)(state >> (typebits -  88)) : 0)] ^
+                table[ 4][(uint8_t)p[11] ^ (typebits >  88 ? (uint8_t)(state >> (typebits -  96)) : 0)] ^
+                table[ 3][(uint8_t)p[12] ^ (typebits >  96 ? (uint8_t)(state >> (typebits - 104)) : 0)] ^
+                table[ 2][(uint8_t)p[13] ^ (typebits > 104 ? (uint8_t)(state >> (typebits - 112)) : 0)] ^
+                table[ 1][(uint8_t)p[14] ^ (typebits > 112 ? (uint8_t)(state >> (typebits - 120)) : 0)] ^
+                table[ 0][(uint8_t)p[15] ^ (typebits > 120 ? (uint8_t)(state >> (typebits - 128)) : 0)];
+    }
+    static const int sh = typebits - 8;
+    for (; p < pp; p ++) {
+        state = table[0][(uint8_t)*p ^ (uint8_t)(state >> sh)] ^ (state << 8);
+    }
+    return state >> (typebits - bitsize);
+}
+/*
+ * [bitsize]
+ *      CRC bit-size. 32 for CRC-32, 7 for CRC-7, and so on.
+ *
+ * [table]
+ *      lookup table.
+ *
+ * [p]
+ *      input sequence.
+ *
+ * [pp]
+ *      end of input sequence.
+ *
+ *      example, p + len(p).
+ *
+ * [state]
+ *      internal state.
+ *
+ *      example, state ^ xor_output.
+ */
+static CRC_INLINE CRC_TYPE
+CRC_REFLECT_UPDATE(int bitsize, const CRC_TYPE table[16][256],
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    const char *pp16 = ((pp - p) & ~0x0f) + p;
+    for (; p < pp16; p += 16) {
+        state = table[15][(uint8_t)p[ 0] ^                   (uint8_t)(state >>   0)     ] ^
+                table[14][(uint8_t)p[ 1] ^ (typebits >   8 ? (uint8_t)(state >>   8) : 0)] ^
+                table[13][(uint8_t)p[ 2] ^ (typebits >  16 ? (uint8_t)(state >>  16) : 0)] ^
+                table[12][(uint8_t)p[ 3] ^ (typebits >  24 ? (uint8_t)(state >>  24) : 0)] ^
+                table[11][(uint8_t)p[ 4] ^ (typebits >  32 ? (uint8_t)(state >>  32) : 0)] ^
+                table[10][(uint8_t)p[ 5] ^ (typebits >  40 ? (uint8_t)(state >>  40) : 0)] ^
+                table[ 9][(uint8_t)p[ 6] ^ (typebits >  48 ? (uint8_t)(state >>  48) : 0)] ^
+                table[ 8][(uint8_t)p[ 7] ^ (typebits >  56 ? (uint8_t)(state >>  56) : 0)] ^
+                table[ 7][(uint8_t)p[ 8] ^ (typebits >  64 ? (uint8_t)(state >>  64) : 0)] ^
+                table[ 6][(uint8_t)p[ 9] ^ (typebits >  72 ? (uint8_t)(state >>  72) : 0)] ^
+                table[ 5][(uint8_t)p[10] ^ (typebits >  80 ? (uint8_t)(state >>  80) : 0)] ^
+                table[ 4][(uint8_t)p[11] ^ (typebits >  88 ? (uint8_t)(state >>  88) : 0)] ^
+                table[ 3][(uint8_t)p[12] ^ (typebits >  96 ? (uint8_t)(state >>  96) : 0)] ^
+                table[ 2][(uint8_t)p[13] ^ (typebits > 104 ? (uint8_t)(state >> 104) : 0)] ^
+                table[ 1][(uint8_t)p[14] ^ (typebits > 112 ? (uint8_t)(state >> 112) : 0)] ^
+                table[ 0][(uint8_t)p[15] ^ (typebits > 120 ? (uint8_t)(state >> 120) : 0)];
+    }
+    for (; p < pp; p ++) {
+        state = table[0][(uint8_t)*p ^ (uint8_t)state] ^ (state >> 8);
+    }
+    return state;
+}
+#ifdef CRC_REFLECT_UPDATE_WITH_BITWISE
+/*
+ * no lookup tables with bitwise.
+ *
+ * reference::
+ *      http://www.hackersdelight.org/hdcodetxt/crc.c.txt#crc32b
+ */
+static CRC_INLINE CRC_TYPE
+CRC_REFLECT_UPDATE_WITH_BITWISE(const int bitsize, CRC_TYPE poly,
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    poly = CRC_BITREFLECT(poly) >> (32 - bitsize);
+    for (; p < pp; p ++) {
+        state ^= (uint8_t)*p;
+        int i;
+        for (i = 0; i < 8; i ++) {
+            state = (state >> 1) ^ (poly & -(state & 1));
+        }
+    }
+    return state;
+}
+#undef CRC_REFLECT_UPDATE_WITH_BITWISE
+#endif
+#ifdef CRC_REFLECT_UPDATE_WITH_BITPACK
+/*
+ * loopless for each bits.
+ *
+ * reference::
+ *      http://www.hackersdelight.org/hdcodetxt/crc.c.txt#crc32h
+ */
+static CRC_INLINE CRC_TYPE
+CRC_REFLECT_UPDATE_WITH_BITPACK(const int bitsize, const CRC_TYPE poly,
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    const CRC_TYPE g0 = CRC_BITREFLECT(poly) >> (32 - bitsize),
+                   g1 = (g0 >> 1) ^ (g0 & -(g0 & 1)),
+                   g2 = (g1 >> 1) ^ (g0 & -(g1 & 1)),
+                   g3 = (g2 >> 1) ^ (g0 & -(g2 & 1)),
+                   g4 = (g3 >> 1) ^ (g0 & -(g3 & 1)),
+                   g5 = (g4 >> 1) ^ (g0 & -(g4 & 1)),
+                   g6 = (g5 >> 1) ^ (g0 & -(g5 & 1)),
+                   g7 = (g6 >> 1) ^ (g0 & -(g6 & 1));
+    for (; p < pp; p ++) {
+        const uint8_t s1 = state ^ *p;
+        state = (g7 & -(CRC_TYPE)((s1 >> 0) & 1)) ^ (g6 & -(CRC_TYPE)((s1 >> 1) & 1)) ^
+                (g5 & -(CRC_TYPE)((s1 >> 2) & 1)) ^ (g4 & -(CRC_TYPE)((s1 >> 3) & 1)) ^
+                (g3 & -(CRC_TYPE)((s1 >> 4) & 1)) ^ (g2 & -(CRC_TYPE)((s1 >> 5) & 1)) ^
+                (g1 & -(CRC_TYPE)((s1 >> 6) & 1)) ^ (g0 & -(CRC_TYPE)((s1 >> 7) & 1)) ^
+                (state >> 8);
+    }
+    return state;
+}
+#undef CRC_REFLECT_UPDATE_WITH_BITPACK
+#endif
+#undef CRC_TYPE
+#undef CRC_BITREFLECT
+#undef CRC_BUILD_TABLES
+#undef CRC_UPDATE
+#undef CRC_BUILD_REFLECT_TABLES
+#undef CRC_REFLECT_UPDATE
+#undef CRC_INLINE

data/ext/crc/crcturbo.c CHANGED Viewed

@@ -228,6 +228,19 @@ bitreflect128(uint128_t n)
 }
 #endif
+static inline unsigned long
+bitreflect_ulong(unsigned long n)
+{
+    if (sizeof(unsigned long) == sizeof(uint64_t)) {
+        return bitreflect64(n);
+    } else if (sizeof(unsigned long) == sizeof(uint32_t)) {
+        return bitreflect32(n);
+    } else {
+        // FIXME
+        return ~0;
+    }
+}
 static inline int
 bitsize_to_type(int bitsize)
 {
@@ -246,131 +259,48 @@ bitsize_to_type(int bitsize)
     }
 }
+#define CRC_TYPE                    uint8_t
+#define CRC_BITREFLECT              bitreflect8
+#define CRC_BUILD_TABLES            crc_build_tables_u8
+#define CRC_UPDATE                  crc_update_u8
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u8
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u8
+#include "crc_imps.h"
+#define CRC_TYPE                    uint16_t
+#define CRC_BITREFLECT              bitreflect16
+#define CRC_BUILD_TABLES            crc_build_tables_u16
+#define CRC_UPDATE                  crc_update_u16
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u16
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u16
+#include "crc_imps.h"
+#define CRC_TYPE                    uint32_t
+#define CRC_BITREFLECT              bitreflect32
+#define CRC_BUILD_TABLES            crc_build_tables_u32
+#define CRC_UPDATE                  crc_update_u32
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u32
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u32
+#include "crc_imps.h"
+#define CRC_TYPE                    uint64_t
+#define CRC_BITREFLECT              bitreflect64
+#define CRC_BUILD_TABLES            crc_build_tables_u64
+#define CRC_UPDATE                  crc_update_u64
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u64
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u64
+#include "crc_imps.h"
-#define IMP_BUILD_TABLE(NAME, TYPE)                                         \
-    static void                                                             \
-    NAME(TYPE table[8][256], int bitsize, TYPE poly)                        \
-    {                                                                       \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;                \
-        poly <<= (typesize - bitsize);                                      \
-        TYPE (*t)[256] = table;                                             \
-        int s, b, i;                                                        \
-        for (s = 0; s < 8; s ++) {                                          \
-            TYPE *p = *t;                                                   \
-            for (b = 0; b < 256; b ++) {                                    \
-                TYPE r = (s == 0) ? ((TYPE)b << (typesize - 8)) : t[-1][b]; \
-                for (i = 0; i < 8; i ++) {                                  \
-                    r = (r << 1) ^ (poly & -(r >> (typesize - 1)));         \
-                }                                                           \
-                *p ++ = r;                                                  \
-            }                                                               \
-            t ++;                                                           \
-        }                                                                   \
-    }
-#define IMP_CRC_UPDATE(NAME, TYPE)                                                                        \
-    static TYPE                                                                                           \
-    NAME(int bitsize, const TYPE table[8][256],                                                           \
-            const char *p, const char *pp, TYPE state)                                                    \
-    {                                                                                                     \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;                                              \
-        const char *pp8 = ((pp - p) & ~0x07) + p;                                                         \
-        state <<= typesize - bitsize;                                                                     \
-        for (; p < pp8; p += 8) {                                                                         \
-            state = table[7][(uint8_t)p[0] ^                  (uint8_t)(state >> (typesize -  8))     ] ^ \
-                    table[6][(uint8_t)p[1] ^ (typesize >  8 ? (uint8_t)(state >> (typesize - 16)) : 0)] ^ \
-                    table[5][(uint8_t)p[2] ^ (typesize > 16 ? (uint8_t)(state >> (typesize - 24)) : 0)] ^ \
-                    table[4][(uint8_t)p[3] ^ (typesize > 24 ? (uint8_t)(state >> (typesize - 32)) : 0)] ^ \
-                    table[3][(uint8_t)p[4] ^ (typesize > 32 ? (uint8_t)(state >> (typesize - 40)) : 0)] ^ \
-                    table[2][(uint8_t)p[5] ^ (typesize > 40 ? (uint8_t)(state >> (typesize - 48)) : 0)] ^ \
-                    table[1][(uint8_t)p[6] ^ (typesize > 48 ? (uint8_t)(state >> (typesize - 56)) : 0)] ^ \
-                    table[0][(uint8_t)p[7] ^ (typesize > 56 ? (uint8_t)(state >> (typesize - 64)) : 0)];  \
-        }                                                                                                 \
-                                                                                                          \
-        int sh = typesize - 8;                                                                            \
-        for (; p < pp; p ++) {                                                                            \
-            state = table[0][(uint8_t)*p ^ (uint8_t)(state >> sh)] ^ (state << 8);                        \
-        }                                                                                                 \
-                                                                                                          \
-        return state >> (typesize - bitsize);                                                             \
-    }                                                                                                     \
-IMP_BUILD_TABLE(build_table8_u8, uint8_t);
-IMP_CRC_UPDATE(crc_update_u8, uint8_t);
-IMP_BUILD_TABLE(build_table8_u16, uint16_t);
-IMP_CRC_UPDATE(crc_update_u16, uint16_t);
-IMP_BUILD_TABLE(build_table8_u32, uint32_t);
-IMP_CRC_UPDATE(crc_update_u32, uint32_t);
-IMP_BUILD_TABLE(build_table8_u64, uint64_t);
-IMP_CRC_UPDATE(crc_update_u64, uint64_t);
-#ifdef HAVE_TYPE_UINT128_T
-IMP_BUILD_TABLE(build_table8_u128, uint128_t);
-IMP_CRC_UPDATE(crc_update_u128, uint128_t);
-#endif
-#undef IMP_BUILD_TABLE
-#define IMP_BUILD_REFLECT_TABLE(NAME, TYPE, BITREFLECT)             \
-    static void                                                     \
-    NAME(TYPE table[8][256], int bitsize, TYPE poly)                \
-    {                                                               \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;        \
-        poly = BITREFLECT(poly << (typesize - bitsize));            \
-        TYPE (*t)[256] = table;                                     \
-        int s, b, i;                                                \
-        for (s = 0; s < 8; s ++) {                                  \
-            TYPE *p = *t;                                           \
-            for (b = 0; b < 256; b ++) {                            \
-                TYPE r = (s == 0) ? (TYPE)b : t[-1][b];             \
-                for (i = 0; i < 8; i ++) {                          \
-                    r = (r >> 1) ^ (poly & -(r & 1));               \
-                }                                                   \
-                *p ++ = r;                                          \
-            }                                                       \
-            t ++;                                                   \
-        }                                                           \
-    }                                                               \
-#define IMP_CRC_REFLECT_UPDATE(NAME, TYPE)                                                   \
-    static TYPE                                                                              \
-    NAME(int bitsize, const TYPE table[8][256],                                              \
-            const char *p, const char *pp, TYPE state)                                       \
-    {                                                                                        \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;                                 \
-        const char *pp8 = ((pp - p) & ~0x07) + p;                                            \
-        for (; p < pp8; p += 8) {                                                            \
-            state = table[7][(uint8_t)p[0] ^                  (uint8_t)(state >>  0)     ] ^ \
-                    table[6][(uint8_t)p[1] ^ (typesize >  8 ? (uint8_t)(state >>  8) : 0)] ^ \
-                    table[5][(uint8_t)p[2] ^ (typesize > 16 ? (uint8_t)(state >> 16) : 0)] ^ \
-                    table[4][(uint8_t)p[3] ^ (typesize > 24 ? (uint8_t)(state >> 24) : 0)] ^ \
-                    table[3][(uint8_t)p[4] ^ (typesize > 32 ? (uint8_t)(state >> 32) : 0)] ^ \
-                    table[2][(uint8_t)p[5] ^ (typesize > 40 ? (uint8_t)(state >> 40) : 0)] ^ \
-                    table[1][(uint8_t)p[6] ^ (typesize > 48 ? (uint8_t)(state >> 48) : 0)] ^ \
-                    table[0][(uint8_t)p[7] ^ (typesize > 56 ? (uint8_t)(state >> 56) : 0)];  \
-        }                                                                                    \
-                                                                                             \
-        for (; p < pp; p ++) {                                                               \
-            state = table[0][(uint8_t)*p ^ (uint8_t)state] ^ (state >> 8);                   \
-        }                                                                                    \
-                                                                                             \
-        return state;                                                                        \
-    }                                                                                        \
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u8, uint8_t, bitreflect8);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u8, uint8_t);
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u16, uint16_t, bitreflect16);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u16, uint16_t);
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u32, uint32_t, bitreflect32);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u32, uint32_t);
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u64, uint64_t, bitreflect64);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u64, uint64_t);
 #ifdef HAVE_TYPE_UINT128_T
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u128, uint128_t, bitreflect128);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u128, uint128_t);
+#   define CRC_TYPE                 uint128_t
+#   define CRC_BITREFLECT           bitreflect128
+#   define CRC_BUILD_TABLES         crc_build_tables_u128
+#   define CRC_UPDATE               crc_update_u128
+#   define CRC_BUILD_REFLECT_TABLES crc_build_reflect_tables_u128
+#   define CRC_REFLECT_UPDATE       crc_reflect_update_u128
+#   include "crc_imps.h"
 #endif
-#undef IMP_BUILD_REFLECT_TABLE
-#undef IMP_CRC_REFLECT_UPDATE
 /*
  *
@@ -396,21 +326,14 @@ struct generator
     int bitsize;
     int flags; /* int type, refin, refout */
     anyuint_t bitmask, polynomial, initial, xorout;
-    union {
-        uint8_t as8[8][256];
-        uint16_t as16[8][256];
-        uint32_t as32[8][256];
-        uint64_t as64[8][256];
-#ifdef HAVE_TYPE_UINT128_T
-        uint128_t as128[8][256];
-#endif
-    } table[0];
+    const void *table; /* entity is String buffer as instance variable */
 };
 static VALUE mCRC;          /* module CRC */
 static VALUE mUtils;        /* module CRC::Utils */
 static VALUE cGenerator;    /* class CRC::Generator */
 static ID generator_iv_name;
+static ID generator_iv_table_buffer;
 static const rb_data_type_t generator_type = {
     .wrap_struct_name = "crc-turbo.CRC::Generator",
@@ -480,10 +403,11 @@ generator_init(int argc, VALUE argv[], VALUE obj)
     generator_init_args(argc, argv, &flags, &bitsize, &poly, &init, &xorout, &name);
     struct generator *p;
-    size_t allocsize = sizeof(struct generator) + (flags & TYPE_MASK) * 256 * 8;
+    size_t allocsize = sizeof(struct generator);
     RTYPEDDATA_DATA(obj) = p = (struct generator *)ALLOC_N(char, allocsize);
     p->bitsize = bitsize;
-    p->flags = flags | TABLE_NOTREADY;
+    p->flags = flags;
+    p->table = NULL;
     /*
      * bitmask の代入でわざわざ1ビット分を後から行う理由は、
@@ -533,11 +457,11 @@ generator_polynomial(VALUE t)
 {
     struct generator *p = get_generator(t);
     SWITCH_BY_TYPE(p->flags,
-            return conv_uint8(p->bitmask.as8),
-            return conv_uint16(p->bitmask.as16),
-            return conv_uint32(p->bitmask.as32),
-            return conv_uint64(p->bitmask.as64),
-            return conv_uint128(p->bitmask.as128));
+            return conv_uint8(p->polynomial.as8),
+            return conv_uint16(p->polynomial.as16),
+            return conv_uint32(p->polynomial.as32),
+            return conv_uint64(p->polynomial.as64),
+            return conv_uint128(p->polynomial.as128));
 }
 static VALUE
@@ -553,7 +477,7 @@ generator_initial_state(VALUE t)
 }
 static VALUE
-generator_table8(VALUE t)
+generator_table(VALUE t)
 {
     struct generator *p = get_generator(t);
     rb_raise(rb_eNotImpError, "");
@@ -608,43 +532,49 @@ static VALUE
 generator_update(VALUE t, VALUE seq, VALUE state)
 {
     struct generator *p = get_generator(t);
+    rb_check_type(seq, RUBY_T_STRING);
+    const char *q = RSTRING_PTR(seq);
+    const char *qq = q + RSTRING_LEN(seq);
-    if (p->flags & TABLE_NOTREADY) {
+    if (!p->table) {
+        size_t tablebytes = (p->flags & TYPE_MASK) * 16 * 256;
+        VALUE tablebuf = rb_str_buf_new(tablebytes);
+        rb_str_set_len(tablebuf, tablebytes);
+        void *table = RSTRING_PTR(tablebuf);
         if (p->flags & REFLECT_INPUT) {
             SWITCH_BY_TYPE(p->flags,
-                    build_reflect_table8_u8(p->table[0].as8, p->bitsize, p->polynomial.as8),
-                    build_reflect_table8_u16(p->table[0].as16, p->bitsize, p->polynomial.as16),
-                    build_reflect_table8_u32(p->table[0].as32, p->bitsize, p->polynomial.as32),
-                    build_reflect_table8_u64(p->table[0].as64, p->bitsize, p->polynomial.as64),
-                    build_reflect_table8_u128(p->table[0].as128, p->bitsize, p->polynomial.as128));
+                    crc_build_reflect_tables_u8(p->bitsize, table, p->polynomial.as8, 16),
+                    crc_build_reflect_tables_u16(p->bitsize, table, p->polynomial.as16, 16),
+                    crc_build_reflect_tables_u32(p->bitsize, table, p->polynomial.as32, 16),
+                    crc_build_reflect_tables_u64(p->bitsize, table, p->polynomial.as64, 16),
+                    crc_build_reflect_tables_u128(p->bitsize, table, p->polynomial.as128, 16));
         } else {
             SWITCH_BY_TYPE(p->flags,
-                    build_table8_u8(p->table[0].as8, p->bitsize, p->polynomial.as8),
-                    build_table8_u16(p->table[0].as16, p->bitsize, p->polynomial.as16),
-                    build_table8_u32(p->table[0].as32, p->bitsize, p->polynomial.as32),
-                    build_table8_u64(p->table[0].as64, p->bitsize, p->polynomial.as64),
-                    build_table8_u128(p->table[0].as128, p->bitsize, p->polynomial.as128));
+                    crc_build_tables_u8(p->bitsize, table, p->polynomial.as8, 16),
+                    crc_build_tables_u16(p->bitsize, table, p->polynomial.as16, 16),
+                    crc_build_tables_u32(p->bitsize, table, p->polynomial.as32, 16),
+                    crc_build_tables_u64(p->bitsize, table, p->polynomial.as64, 16),
+                    crc_build_tables_u128(p->bitsize, table, p->polynomial.as128, 16));
         }
-        p->flags ^= TABLE_NOTREADY;
+        rb_ivar_set(t, generator_iv_table_buffer, tablebuf);
+        rb_obj_freeze(tablebuf);
+        p->table = table;
     }
-    rb_check_type(seq, RUBY_T_STRING);
-    const char *q = RSTRING_PTR(seq);
-    const char *qq = q + RSTRING_LEN(seq);
     if (p->flags & REFLECT_INPUT) {
         SWITCH_BY_TYPE(p->flags,
-                return conv_uint8(crc_reflect_update_u8(p->bitsize, p->table[0].as8, q, qq, to_uint8(state))),
-                return conv_uint16(crc_reflect_update_u16(p->bitsize, p->table[0].as16, q, qq, to_uint16(state))),
-                return conv_uint32(crc_reflect_update_u32(p->bitsize, p->table[0].as32, q, qq, to_uint32(state))),
-                return conv_uint64(crc_reflect_update_u64(p->bitsize, p->table[0].as64, q, qq, to_uint64(state))),
-                return conv_uint128(crc_reflect_update_u128(p->bitsize, p->table[0].as128, q, qq, to_uint128(state))));
+                return conv_uint8(crc_reflect_update_u8(p->bitsize, p->table, q, qq, to_uint8(state))),
+                return conv_uint16(crc_reflect_update_u16(p->bitsize, p->table, q, qq, to_uint16(state))),
+                return conv_uint32(crc_reflect_update_u32(p->bitsize, p->table, q, qq, to_uint32(state))),
+                return conv_uint64(crc_reflect_update_u64(p->bitsize, p->table, q, qq, to_uint64(state))),
+                return conv_uint128(crc_reflect_update_u128(p->bitsize, p->table, q, qq, to_uint128(state))));
     } else {
         SWITCH_BY_TYPE(p->flags,
-                return conv_uint8(crc_update_u8(p->bitsize, p->table[0].as8, q, qq, to_uint8(state))),
-                return conv_uint16(crc_update_u16(p->bitsize, p->table[0].as16, q, qq, to_uint16(state))),
-                return conv_uint32(crc_update_u32(p->bitsize, p->table[0].as32, q, qq, to_uint32(state))),
-                return conv_uint64(crc_update_u64(p->bitsize, p->table[0].as64, q, qq, to_uint64(state))),
-                return conv_uint128(crc_update_u128(p->bitsize, p->table[0].as128, q, qq, to_uint128(state))));
+                return conv_uint8(crc_update_u8(p->bitsize, p->table, q, qq, to_uint8(state))),
+                return conv_uint16(crc_update_u16(p->bitsize, p->table, q, qq, to_uint16(state))),
+                return conv_uint32(crc_update_u32(p->bitsize, p->table, q, qq, to_uint32(state))),
+                return conv_uint64(crc_update_u64(p->bitsize, p->table, q, qq, to_uint64(state))),
+                return conv_uint128(crc_update_u128(p->bitsize, p->table, q, qq, to_uint128(state))));
     }
 }
@@ -679,10 +609,27 @@ utils_s_bitref64(VALUE mod, VALUE num)
 static VALUE
 utils_s_bitref128(VALUE mod, VALUE num)
 {
-#ifdef HAVE_TYPE_UINT128_T
-    return conv_uint128(bitreflect128(to_uint128(num)));
-#endif
-    rb_raise(rb_eNotImpError, "");
+    if (sizeof(unsigned long) < 16) {
+        static const int len = sizeof(char[16]) / sizeof(unsigned long);
+        unsigned long tmp[len + 1];
+        rb_big_pack(num, tmp, len);
+        unsigned long *p = tmp;
+        unsigned long *q = p + len;
+        while (p < q) {
+            unsigned long tmp1 = bitreflect_ulong(*p);
+            *p ++ = bitreflect_ulong(*-- q);
+            *q = tmp1;
+        }
+        tmp[len] = 0;
+        return rb_big_unpack(tmp, len + 1);
+    } else {
+        unsigned long n[2];
+        rb_big_pack(num, n, 1);
+        n[0] =  (unsigned long)bitreflect64(n[0] >> 64)       |
+               ((unsigned long)bitreflect64(n[0]      ) << 64);
+        n[1] = 0;
+        return rb_big_unpack(n, 2);
+    }
 }
 /*
@@ -693,6 +640,7 @@ void
 Init__turbo(void)
 {
     generator_iv_name = rb_intern("crc-turbo.CRC::Generator.name");
+    generator_iv_table_buffer = rb_intern("crc-turbo.CRC::Generator.table-buffer");
     mCRC = rb_define_module("CRC");
@@ -710,7 +658,7 @@ Init__turbo(void)
     rb_define_method(cGenerator, "bitmask", generator_bitmask, 0);
     rb_define_method(cGenerator, "polynomial", generator_polynomial, 0);
     rb_define_method(cGenerator, "initial_state", generator_initial_state, 0);
-    rb_define_method(cGenerator, "table8", generator_table8, 0);
+    rb_define_method(cGenerator, "table", generator_table, 0);
     rb_define_method(cGenerator, "reflect_input", generator_reflect_input, 0);
     rb_define_method(cGenerator, "reflect_output", generator_reflect_output, 0);
     rb_define_method(cGenerator, "xor_output", generator_xor_output, 0);

data/gemstub.rb CHANGED Viewed

@@ -1,19 +1,19 @@
 GEMSTUB = Gem::Specification.new do |s|
   s.name = "crc-turbo"
-  s.version = "0.1"
+  s.version = "0.2"
   s.summary = "general CRC generator"
   s.description = <<EOS
 This is a C extention for "crc" gem library.
-Just install this, and "require 'crc'". Additional other work is not required.
+Just install this, and to do "require 'crc'" only. Additional other work is not required.
 EOS
   s.homepage = "https://osdn.jp/projects/rutsubo/"
-  s.license = "BSD-2-Clause"
+  s.licenses = ["BSD-2-Clause", "CC0-1.0"]
   s.author = "dearblue"
   s.email = "dearblue@users.osdn.me"
   s.required_ruby_version = ">= 2.0"
   s.add_development_dependency "rake", "~> 11.0"
-  s.add_runtime_dependency "crc", "~> 0.1"
+  s.add_runtime_dependency "crc", "~> 0.2"
 end
 EXTMAP["crc"] = "crc/_turbo"

data/lib/crc/2.0/_turbo.so CHANGED Viewed

Binary file

data/lib/crc/2.1/_turbo.so CHANGED Viewed

Binary file

data/lib/crc/2.2/_turbo.so CHANGED Viewed

Binary file

data/lib/crc/2.3/_turbo.so CHANGED Viewed

Binary file

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crc-turbo
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: x86-mingw32
 authors:
 - dearblue
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-08 00:00:00.000000000 Z
+date: 2016-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -30,28 +30,32 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 description: |
   This is a C extention for "crc" gem library.
-  Just install this, and "require 'crc'". Additional other work is not required.
+  Just install this, and to do "require 'crc'" only. Additional other work is not required.
 email: dearblue@users.osdn.me
 executables: []
 extensions: []
 extra_rdoc_files:
+- HISTORY.ja.md
 - LICENSE
 - README.md
+- ext/crc/crc_imps.h
 - ext/crc/crcturbo.c
 files:
+- HISTORY.ja.md
 - LICENSE
 - README.md
 - Rakefile
+- ext/crc/crc_imps.h
 - ext/crc/crcturbo.c
 - ext/crc/extconf.rb
 - gemstub.rb
@@ -62,6 +66,7 @@ files:
 homepage: https://osdn.jp/projects/rutsubo/
 licenses:
 - BSD-2-Clause
+- CC0-1.0
 metadata: {}
 post_install_message:
 rdoc_options:
@@ -83,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.2
+rubygems_version: 2.6.4
 signing_key:
 specification_version: 4
 summary: general CRC generator