crc-turbo 0.2-x86-mingw32 → 0.3-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 019207cb17862096bb83b5ab102ca7fc5ac1d372
-  data.tar.gz: 025ab1256a46655f1ed2cc75b4d44b868474aafc
+  metadata.gz: e3f7657cd03168447650953f2f45a192ca524a2f
+  data.tar.gz: 7fb40a997e3044b4b8d4111346b4bff5baf7e935
 SHA512:
-  metadata.gz: 9213fc2651da32478981d4bac664e13b6810bd5375aec627027bcb50b5b769da27d8dbd0a89e4f4eb3fedf9522d6519d603b61a9c9d2af3f4e7570f72c512012
-  data.tar.gz: 882bd8bca35dbcdde5f2f50bd4616a9d2b1f192d183483bb8609154f12b16f64d8346da34871e38b919cb978fe2d101642a514bbe82d7706f873e1d6ec3d67a5
+  metadata.gz: 758b38d47f51aad43ebee00049730d1f1afdd567822fc71ac2f36f5b63ee7af1a04b6bf96f20850fc1c56bb9fc13f18871c1ccbf8491c64f538cab933e1bea58
+  data.tar.gz: 0d432aeb70d85bcab2f285d8b81510670ace05e1c2829df21fe9152c26ed264021405bb1ef175dfd1ce5ee1acb327c6d4ef8bdd25d0970ed85023862a0954d5b

data/HISTORY.ja.md

@@ -2,6 +2,10 @@ This document is written in Japanese.
 
 # crc-turbo for ruby の更新履歴
 
+## crc-0.3
+
+  * crc-0.3 に追従して、CRC::BasicCRC と CRC::Generator を CRC に統合
+
 ## crc-0.2 (平成28年5月15日 (日))
 
   * \[FIX\] CRC::Generator#polynomial メソッドが間違った値を返していた問題を修正

data/README.md

@@ -12,12 +12,12 @@ Just install this, and to do "require 'crc'" only. Additional other work is not
   * 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.2
+  * version: 0.3
   * release quality: thechnical preview
   * 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
+  * dependency gems: crc-0.3 (<https://rubygems/gems/crc>)
+  * dependency external C libraries: none
+  * bundled external C libraries: none
 
 
 ## How to usage
@@ -26,8 +26,6 @@ First, install on your system.
 
 ``` shell:shell
 # gem install crc-turbo
-.....
-#
 ```
 
 And, to do ``require "crc"``.

data/ext/crc/crc_imps.h

@@ -4,7 +4,7 @@
  *
  * This is a general CRC generator.
  *
- * It's used slice-by-16 algorithm with byte-order free and byte-alignment free.
+ * It's used slice-by-16 algorithm with byte-order free.
  * This is based on the Intel's slice-by-eight algorithm.
  *
  * Worst point is need more memory!

data/ext/crc/crcturbo.c

@@ -16,15 +16,16 @@ enum {
     TABLE_NOTREADY = 0x1000,
 };
 
-#define SWITCH_BY_TYPE(FLAGS, STMT_U8, STMT_U16, STMT_U32, STMT_U64, STMT_U128) \
-    switch ((FLAGS) & TYPE_MASK) {                                              \
-    case TYPE_UINT8_T:      { STMT_U8; break; }                                 \
-    case TYPE_UINT16_T:     { STMT_U16; break; }                                \
-    case TYPE_UINT32_T:     { STMT_U32; break; }                                \
-    case TYPE_UINT64_T:     { STMT_U64; break; }                                \
- /* case TYPE_UINT128_T:    { STMT_U128; break; } */                            \
-    default: { rb_bug(" [INVALID TYPE FLAGS: 0x%02X] ", (FLAGS) & TYPE_MASK); } \
-    }                                                                           \
+//#define SNNIPET(BITSIZE, AS, TYPE, TOUINT, CONVUINT)
+#define SWITCH_BY_TYPE(TYPE, SNNIPET)                                                            \
+    switch ((TYPE)) {                                                                            \
+    case TYPE_UINT8_T:   { SNNIPET(  8,   as8,   uint8_t,   to_uint8,   conv_uint8); break; }    \
+    case TYPE_UINT16_T:  { SNNIPET( 16,  as16,  uint16_t,  to_uint16,  conv_uint16); break; }    \
+    case TYPE_UINT32_T:  { SNNIPET( 32,  as32,  uint32_t,  to_uint32,  conv_uint32); break; }    \
+    case TYPE_UINT64_T:  { SNNIPET( 64,  as64,  uint64_t,  to_uint64,  conv_uint64); break; }    \
+ /* case TYPE_UINT128_T: { SNNIPET(128, as128, uint128_t, to_uint128, conv_uint128); break; } */ \
+    default: { rb_bug(" [INVALID TYPE FLAGS: 0x%02X] ", (TYPE)); }                               \
+    }                                                                                            \
 
 static inline uint8_t
 to_uint8(VALUE num)
@@ -321,52 +322,50 @@ typedef struct anyuint_t
     };
 } anyuint_t;
 
-struct generator
+struct crc_module
 {
-    int bitsize;
-    int flags; /* int type, refin, refout */
+    uint32_t bitsize:10;
+    uint32_t type:10;
+    uint32_t reflect_input:1;
+    uint32_t reflect_output:1;
+
     anyuint_t bitmask, polynomial, initial, xorout;
     const void *table; /* entity is String buffer as instance variable */
 };
 
-static VALUE mCRC;          /* module CRC */
+static VALUE cCRC;          /* class 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 ID ext_iv_name;
+static ID ext_iv_module;
+static ID ext_iv_table_buffer;
 
-static const rb_data_type_t generator_type = {
-    .wrap_struct_name = "crc-turbo.CRC::Generator",
+static const rb_data_type_t ext_type = {
+    .wrap_struct_name = "crc-turbo.CRC.module",
     .function.dmark = NULL,
     .function.dsize = NULL,
     .function.dfree = (void *)-1,
 };
 
-static void
-check_generator_notinit(VALUE obj)
-{
-    struct generator *p;
-    TypedData_Get_Struct(obj, struct generator, &generator_type, p);
-    if (p) { rb_raise(rb_eArgError, "already initialized object - #<%s:0x%p>", rb_obj_classname(obj), (void *)obj); }
-}
-
-static struct generator *
-get_generator(VALUE obj)
+static struct crc_module *
+get_modulep(VALUE obj)
 {
-    struct generator *p;
-    TypedData_Get_Struct(obj, struct generator, &generator_type, p);
-    if (!p) { rb_raise(rb_eArgError, "wrong initialized object - #<%s:0x%p>", rb_obj_classname(obj), (void *)obj); }
+    struct crc_module *p;
+    obj = rb_ivar_get(obj, ext_iv_module);
+    if (NIL_P(obj)) { return NULL; }
+    TypedData_Get_Struct(obj, struct crc_module, &ext_type, p);
     return p;
 }
 
-static VALUE
-generator_alloc(VALUE mod)
+static struct crc_module *
+get_module(VALUE obj)
 {
-    return TypedData_Wrap_Struct(mod, &generator_type, NULL);
+    struct crc_module *p = get_modulep(obj);
+    if (!p) { rb_raise(rb_eTypeError, "wrong initialized object - #<%s:0x%p>", rb_obj_classname(obj), (void *)obj); }
+    return p;
 }
 
 static void
-generator_init_args(int argc, VALUE argv[], int *flags, int *bitsize, VALUE *poly, VALUE *init, VALUE *xorout, VALUE *name)
+ext_init_args(int argc, VALUE argv[], int *flags, int *bitsize, VALUE *poly, VALUE *init, VALUE *xorout, VALUE *name)
 {
     rb_check_arity(argc, 2, 7);
     *bitsize = NUM2INT(argv[0]);
@@ -390,191 +389,180 @@ generator_init_args(int argc, VALUE argv[], int *flags, int *bitsize, VALUE *pol
     *name = (argc > 6 && !NIL_P(argv[6])) ? rb_String(argv[6]) : Qnil;
 }
 
-/*
- * call-seq:
- *  initialize(bitsize, polynomial, initial_state = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil)
- */
 static VALUE
-generator_init(int argc, VALUE argv[], VALUE obj)
+ext_s_new(int argc, VALUE argv[], VALUE crc)
 {
-    int flags, bitsize;
-    VALUE poly, init, xorout, name;
-    check_generator_notinit(obj);
-    generator_init_args(argc, argv, &flags, &bitsize, &poly, &init, &xorout, &name);
-
-    struct generator *p;
-    size_t allocsize = sizeof(struct generator);
-    RTYPEDDATA_DATA(obj) = p = (struct generator *)ALLOC_N(char, allocsize);
-    p->bitsize = bitsize;
-    p->flags = flags;
-    p->table = NULL;
-
-    /*
-     * bitmask の代入でわざわざ1ビット分を後から行う理由は、
-     * 例えば uint8_t に対して << 8 をすると何もしないため、
-     * これへの対処を目的とする。
-     */
-#define INIT_GENERATOR(TYPE, AS, TO_UINT, CONV_UINT, P, BITSIZE, POLY, INIT, XOROUT)   \
-    P->bitmask.AS = ~(~(TYPE)0 << 1 << (BITSIZE - 1));                              \
-    P->polynomial.AS = P->bitmask.AS & TO_UINT(POLY);                               \
-    P->initial.AS = P->bitmask.AS & TO_UINT(INIT);                                  \
-    P->xorout.AS = P->bitmask.AS & TO_UINT(XOROUT);                                 \
-
-    SWITCH_BY_TYPE(flags,
-            INIT_GENERATOR(uint8_t, as8, to_uint8, conv_uint8, p, bitsize, poly, init, xorout),
-            INIT_GENERATOR(uint16_t, as16, to_uint16, conv_uint16, p, bitsize, poly, init, xorout),
-            INIT_GENERATOR(uint32_t, as32, to_uint32, conv_uint32, p, bitsize, poly, init, xorout),
-            INIT_GENERATOR(uint64_t, as64, to_uint64, conv_uint64, p, bitsize, poly, init, xorout),
-            INIT_GENERATOR(uint128_t, as128, to_uint128, conv_uint128, p, bitsize, poly, init, xorout));
-
-#undef INIT_GENERATOR
-
-    rb_ivar_set(obj, generator_iv_name, name);
-
-    return obj;
+    if (get_modulep(crc)) {
+        return rb_call_super(argc, argv);
+    } else {
+        int flags, bitsize;
+        VALUE poly, init, xorout, name;
+        ext_init_args(argc, argv, &flags, &bitsize, &poly, &init, &xorout, &name);
+
+        struct crc_module *p;
+        VALUE crcmod = TypedData_Make_Struct(crc, struct crc_module, &ext_type, p);
+
+        p->bitsize = bitsize;
+        p->type = flags & TYPE_MASK;
+        p->reflect_input = ((flags & REFLECT_INPUT) != 0) ? 1 : 0;
+        p->reflect_output = ((flags & REFLECT_OUTPUT) != 0) ? 1 : 0;
+        p->table = NULL;
+
+        /*
+         * bitmask の代入でわざわざ1ビット分を後から行う理由は、
+         * 例えば uint8_t に対して << 8 をすると何もしないため、
+         * これへの対処を目的とする。
+         */
+#define SNNIPET_INIT_MOD(BITSIZE, AS, TYPE, TOUINT, CONVUINT)  \
+        p->bitmask.AS = ~(~(TYPE)0 << 1 << (bitsize - 1));     \
+        p->polynomial.AS = p->bitmask.AS & TOUINT(poly);       \
+        p->initial.AS = p->bitmask.AS & TOUINT(init);          \
+        p->xorout.AS = p->bitmask.AS & TOUINT(xorout);         \
+
+        SWITCH_BY_TYPE(p->type, SNNIPET_INIT_MOD);
+
+        VALUE newcrc = rb_define_class_id(0, crc);
+        rb_ivar_set(newcrc, ext_iv_module, crcmod);
+        rb_ivar_set(newcrc, ext_iv_name, name);
+
+        rb_extend_object(newcrc, rb_const_get(cCRC, rb_intern("ModuleClass")));
+        rb_define_alias(rb_singleton_class(newcrc), "[]", "new");
+
+        return newcrc;
+    }
 }
 
 static VALUE
-generator_bitsize(VALUE t)
+ext_bitsize(VALUE t)
 {
-    return INT2FIX(get_generator(t)->bitsize);
+    return INT2FIX(get_module(t)->bitsize);
 }
 
 static VALUE
-generator_bitmask(VALUE t)
+ext_bitmask(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));
+    struct crc_module *p = get_module(t);
+
+#define SNNIPET_BITMASK(BITSIZE, AS, TYPE, TOUINT, CONVUINT) \
+    return CONVUINT(p->bitmask.AS);                          \
+
+    SWITCH_BY_TYPE(p->type, SNNIPET_BITMASK);
 }
 
 static VALUE
-generator_polynomial(VALUE t)
+ext_polynomial(VALUE t)
 {
-    struct generator *p = get_generator(t);
-    SWITCH_BY_TYPE(p->flags,
-            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));
+    struct crc_module *p = get_module(t);
+
+#define SNNIPET_POLYNOMIAL(BITSIZE, AS, TYPE, TOUINT, CONVUINT) \
+    return CONVUINT(p->polynomial.AS);                          \
+
+    SWITCH_BY_TYPE(p->type, SNNIPET_POLYNOMIAL);
 }
 
 static VALUE
-generator_initial_state(VALUE t)
+ext_initial_crc(VALUE t)
 {
-    struct generator *p = get_generator(t);
-    SWITCH_BY_TYPE(p->flags,
-            return conv_uint8(p->initial.as8),
-            return conv_uint16(p->initial.as16),
-            return conv_uint32(p->initial.as32),
-            return conv_uint64(p->initial.as64),
-            return conv_uint128(p->initial.as128));
+    struct crc_module *p = get_module(t);
+
+#define SNNIPET_INITIAL_CRC(BITSIZE, AS, TYPE, TOUINT, CONVUINT) \
+    return CONVUINT(p->initial.AS);                              \
+
+    SWITCH_BY_TYPE(p->type, SNNIPET_INITIAL_CRC);
 }
 
 static VALUE
-generator_table(VALUE t)
+ext_table(VALUE t)
 {
-    struct generator *p = get_generator(t);
+    struct crc_module *p = get_module(t);
     rb_raise(rb_eNotImpError, "");
 }
 
 static VALUE
-generator_reflect_input(VALUE t)
+ext_reflect_input(VALUE t)
 {
-    struct generator *p = get_generator(t);
-    return (p->flags & REFLECT_INPUT) ? Qtrue : Qfalse;
+    struct crc_module *p = get_module(t);
+    return (p->reflect_input != 0) ? Qtrue : Qfalse;
 }
 
 static VALUE
-generator_reflect_output(VALUE t)
+ext_reflect_output(VALUE t)
 {
-    struct generator *p = get_generator(t);
-    return (p->flags & REFLECT_OUTPUT) ? Qtrue : Qfalse;
+    struct crc_module *p = get_module(t);
+    return (p->reflect_output != 0) ? Qtrue : Qfalse;
 }
 
 static VALUE
-generator_xor_output(VALUE t)
+ext_xor_output(VALUE t)
 {
-    struct generator *p = get_generator(t);
-    SWITCH_BY_TYPE(p->flags,
-            return conv_uint8(p->xorout.as8),
-            return conv_uint16(p->xorout.as16),
-            return conv_uint32(p->xorout.as32),
-            return conv_uint64(p->xorout.as64),
-            return conv_uint128(p->xorout.as128));
+    struct crc_module *p = get_module(t);
+
+#define SNNIPET_XOR_OUTPUT(BITSIZE, AS, TYPE, TOUINT, CONVUINT) \
+    return CONVUINT(p->xorout.AS);                              \
+
+    SWITCH_BY_TYPE(p->type, SNNIPET_XOR_OUTPUT);
 }
 
 static VALUE
-generator_name(VALUE t)
+ext_name(VALUE t)
 {
-    // get_generator で初期化の確認
-    get_generator(t);
+    // get_module で初期化の確認
+    get_module(t);
 
-    return rb_ivar_get(t, generator_iv_name);
+    return rb_ivar_get(t, ext_iv_name);
 }
 
 static VALUE
-generator_set_name(VALUE t, VALUE name)
+ext_set_name(VALUE t, VALUE name)
 {
-    // get_generator で初期化の確認
-    get_generator(t);
+    // get_module で初期化の確認
+    get_module(t);
 
-    rb_ivar_set(t, generator_iv_name, rb_String(name));
+    rb_ivar_set(t, ext_iv_name, rb_String(name));
     return name;
 }
 
 static VALUE
-generator_update(VALUE t, VALUE seq, VALUE state)
+ext_update(VALUE t, VALUE seq, VALUE state)
 {
-    struct generator *p = get_generator(t);
+    struct crc_module *p = get_module(t);
     rb_check_type(seq, RUBY_T_STRING);
     const char *q = RSTRING_PTR(seq);
     const char *qq = q + RSTRING_LEN(seq);
 
     if (!p->table) {
-        size_t tablebytes = (p->flags & TYPE_MASK) * 16 * 256;
+        size_t tablebytes = (p->type) * 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,
-                    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));
+        if (p->reflect_input) {
+#define SNNIPET_BUILD_REFTABLE(BITSIZE, AS, TYPE, TOUINT, CONVUINT)                       \
+            crc_build_reflect_tables_u##BITSIZE(p->bitsize, table, p->polynomial.AS, 16); \
+
+            SWITCH_BY_TYPE(p->type, SNNIPET_BUILD_REFTABLE);
         } else {
-            SWITCH_BY_TYPE(p->flags,
-                    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));
+#define SNNIPET_BUILD_TABLE(BITSIZE, AS, TYPE, TOUINT, CONVUINT)                  \
+            crc_build_tables_u##BITSIZE(p->bitsize, table, p->polynomial.AS, 16); \
+
+            SWITCH_BY_TYPE(p->type, SNNIPET_BUILD_TABLE);
         }
-        rb_ivar_set(t, generator_iv_table_buffer, tablebuf);
+        rb_ivar_set(t, ext_iv_table_buffer, tablebuf);
         rb_obj_freeze(tablebuf);
         p->table = table;
     }
 
-    if (p->flags & REFLECT_INPUT) {
-        SWITCH_BY_TYPE(p->flags,
-                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))));
+    if (p->reflect_input) {
+#define SNNIPET_REFUPDATE(BITSIZE, AS, TYPE, TOUINT, CONVUINT)      \
+        return CONVUINT(crc_reflect_update_u##BITSIZE(              \
+                    p->bitsize, p->table, q, qq, TOUINT(state)));   \
+
+        SWITCH_BY_TYPE(p->type, SNNIPET_REFUPDATE);
     } else {
-        SWITCH_BY_TYPE(p->flags,
-                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))));
+#define SNNIPET_UPDATE(BITSIZE, AS, TYPE, TOUINT, CONVUINT)         \
+        return CONVUINT(crc_update_u##BITSIZE(                      \
+                    p->bitsize, p->table, q, qq, TOUINT(state)));   \
+
+        SWITCH_BY_TYPE(p->type, SNNIPET_UPDATE);
     }
 }
 
@@ -639,30 +627,28 @@ utils_s_bitref128(VALUE mod, VALUE num)
 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");
-
-    mUtils = rb_define_module_under(mCRC, "Utils");
+    ext_iv_name = rb_intern("crc-turbo.CRC.name");
+    ext_iv_module = rb_intern("crc-turbo.CRC.module");
+    ext_iv_table_buffer = rb_intern("crc-turbo.CRC.table-buffer");
+
+    cCRC = rb_define_class("CRC", rb_cObject);
+    rb_define_singleton_method(cCRC, "new", ext_s_new, -1);
+    rb_define_singleton_method(cCRC, "bitsize", ext_bitsize, 0);
+    rb_define_singleton_method(cCRC, "bitmask", ext_bitmask, 0);
+    rb_define_singleton_method(cCRC, "polynomial", ext_polynomial, 0);
+    rb_define_singleton_method(cCRC, "initial_crc", ext_initial_crc, 0);
+    rb_define_singleton_method(cCRC, "table", ext_table, 0);
+    rb_define_singleton_method(cCRC, "reflect_input?", ext_reflect_input, 0);
+    rb_define_singleton_method(cCRC, "reflect_output?", ext_reflect_output, 0);
+    rb_define_singleton_method(cCRC, "xor_output", ext_xor_output, 0);
+    rb_define_singleton_method(cCRC, "name", ext_name, 0);
+    rb_define_singleton_method(cCRC, "name=", ext_set_name, 1);
+    rb_define_singleton_method(cCRC, "update", ext_update, 2);
+
+    mUtils = rb_define_module_under(cCRC, "Utils");
     rb_define_method(mUtils, "bitreflect8", utils_s_bitref8, 1);
     rb_define_method(mUtils, "bitreflect16", utils_s_bitref16, 1);
     rb_define_method(mUtils, "bitreflect32", utils_s_bitref32, 1);
     rb_define_method(mUtils, "bitreflect64", utils_s_bitref64, 1);
     rb_define_method(mUtils, "bitreflect128", utils_s_bitref128, 1);
-
-    cGenerator = rb_define_class_under(mCRC, "Generator", rb_cObject);
-    rb_define_alloc_func(cGenerator, generator_alloc);
-    rb_define_method(cGenerator, "initialize", generator_init, -1);
-    rb_define_method(cGenerator, "bitsize", generator_bitsize, 0);
-    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, "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);
-    rb_define_method(cGenerator, "name", generator_name, 0);
-    rb_define_method(cGenerator, "name=", generator_set_name, 1);
-    rb_define_method(cGenerator, "update", generator_update, 2);
 }

data/gemstub.rb

@@ -1,6 +1,6 @@
 GEMSTUB = Gem::Specification.new do |s|
   s.name = "crc-turbo"
-  s.version = "0.2"
+  s.version = "0.3"
   s.summary = "general CRC generator"
   s.description = <<EOS
 This is a C extention for "crc" gem library.
@@ -12,8 +12,8 @@ EOS
   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.2"
+  s.add_development_dependency "rake"
+  s.add_runtime_dependency "crc", "~> 0.3"
 end
 
 EXTMAP["crc"] = "crc/_turbo"

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: crc-turbo
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: x86-mingw32
 authors:
 - dearblue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-15 00:00:00.000000000 Z
+date: 2016-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: crc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 description: |
   This is a C extention for "crc" gem library.
   Just install this, and to do "require 'crc'" only. Additional other work is not required.
@@ -93,4 +93,3 @@ signing_key:
 specification_version: 4
 summary: general CRC generator
 test_files: []
-has_rdoc: