crc 0.3 → 0.4.2

data/lib/crc/_aux.rb

@@ -0,0 +1,37 @@
+class CRC
+  #
+  # Internal using module.
+  #
+  module Aux
+    def self.DIGEST(num, bitsize)
+      bits = (bitsize + 7) / 8 * 8
+      seq = ""
+      (bits - 8).step(0, -8) { |i| seq << yield((num >> i) & 0xff) }
+      seq
+    end
+
+    def self.digest(num, bitsize)
+      DIGEST(num, bitsize) { |n| n.chr(Encoding::BINARY) }
+    end
+
+    def self.hexdigest(num, bitsize)
+      DIGEST(num, bitsize) { |n| "%02X" % n }
+    end
+
+    #
+    # call-seq:
+    #   slide_to_head(bitsize, state, polynomial, bitmask) { |padded_state, padded_polynomial, shift_input, off_msb, carries_mask, padding_size| padded_new_state } -> new_state
+    #
+    # YIELD(padded_state, padded_polynomial, shift_input, off_msb, carries_mask, padding_size) -> padded_new_state
+    #
+    def self.slide_to_head(bitsize, state, polynomial, bitmask)
+      pad = bitsize & 0x07
+      if pad == 0
+        yield(state, polynomial, bitsize - 8, bitsize - 1, bitmask >> 1, 0)
+      else
+        pad = 8 - pad
+        yield(state << pad, polynomial << pad, bitsize - 8 + pad, bitsize - 1 + pad, (bitmask << pad >> 1) | 0x7f, pad) >> pad
+      end
+    end
+  end
+end

data/lib/crc/_byruby.rb

@@ -1,14 +1,15 @@
 #!ruby
 
 #--
-# Author:: dearblue <dearblue@users.osdn.me>
+# File:: _byruby.rb
+# Author:: dearblue <dearblue@users.noreply.github.com>
 # License:: Creative Commons License Zero (CC0 / Public Domain)
 #++
 
 #
 # \* \* \* \* \* \* \* \*
 #
-# Ruby implemented CRC generator.
+# Pure ruby implemented generic CRC calculator.
 # It's used slice-by-16 algorithm with byte-order free.
 # This is based on the Intel's slice-by-eight algorithm.
 #
@@ -22,17 +23,12 @@
 #   * xz-5.2.2/src/liblzma/check/crc32_fast.c
 #   * xz-5.2.2/src/liblzma/check/crc32_tablegen.c
 #
-# If defined "RUBY_CRC_NOFAST=2" enviroment variable, switch to lookup-table algorithm.
-#
-# If defined "RUBY_CRC_NOFAST=3" enviroment variable, switch to reference algorithm.
-#
 class CRC
   class << self
     #
     # call-seq:
-    #   new(bitsize, polynomial, initial_crc = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil) -> new crc module class (CRC based class)
-    #   new(initial_crc = nil, size = 0) -> new crc generator (CRC instance)
-    #   new(seq, initial_crc = nil, size = 0) -> new crc generator (CRC instance)
+    #   new(bitsize, polynomial, initial_crc = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil) -> new crc model class (CRC based class)
+    #   new(initial_crc = nil, size = 0) -> new crc calculator (CRC instance)
     #
     def new(bitsize, polynomial, initial_crc = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil)
       bitsize = bitsize.to_i
@@ -60,11 +56,7 @@ class CRC
         # CRC クラスを普通に派生させた場合でも、CRC.new の基底メソッドが呼ばれるための細工
         define_singleton_method(:new, &Class.instance_method(:new).bind(self))
 
-        singleton_class.class_eval do
-          alias_method :[], :new
-        end
-
-        extend CRC::ModuleClass
+        extend CRC::Calculator
       end
     end
 
@@ -111,7 +103,7 @@ class CRC
       end
     end
 
-    def update_with_slice_by_eight(seq, s)
+    def update_with_slice_by_16(seq, s)
       tX = table
       t0 = tX[ 0]; t1 = tX[ 1]; t2 = tX[ 2]; t3 = tX[ 3]
       t4 = tX[ 4]; t5 = tX[ 5]; t6 = tX[ 6]; t7 = tX[ 7]
@@ -120,15 +112,29 @@ class CRC
 
       i = 0
       ii = seq.bytesize
-      iii = ii & ~15
+      ii16 = ii & ~15
 
       if reflect_input
-        if bitsize <= 32
-          # speed improvement for 32-bits CRC
+        case
+        when bitsize > 32
           i = 0
-          while i < iii
+          while i < ii16
             s = tF[seq.getbyte(i     ) ^ (s      ) & 0xff] ^ tE[seq.getbyte(i +  1) ^ (s >>  8) & 0xff] ^
                 tD[seq.getbyte(i +  2) ^ (s >> 16) & 0xff] ^ tC[seq.getbyte(i +  3) ^ (s >> 24) & 0xff] ^
+                tB[seq.getbyte(i +  4) ^ (s >> 32) & 0xff] ^ tA[seq.getbyte(i +  5) ^ (s >> 40) & 0xff] ^
+                t9[seq.getbyte(i +  6) ^ (s >> 48) & 0xff] ^ t8[seq.getbyte(i +  7) ^ (s >> 56)       ] ^
+                t7[seq.getbyte(i +  8)                   ] ^ t6[seq.getbyte(i +  9)                   ] ^
+                t5[seq.getbyte(i + 10)                   ] ^ t4[seq.getbyte(i + 11)                   ] ^
+                t3[seq.getbyte(i + 12)                   ] ^ t2[seq.getbyte(i + 13)                   ] ^
+                t1[seq.getbyte(i + 14)                   ] ^ t0[seq.getbyte(i + 15)                   ]
+            i += 16
+          end
+        when bitsize > 16
+          # speed improvement for 32-bits CRC
+          i = 0
+          while i < ii16
+            s = tF[seq.getbyte(i     ) ^ (s      ) & 0xff] ^ tE[seq.getbyte(i +  1) ^ (s >>  8) & 0xff] ^
+                tD[seq.getbyte(i +  2) ^ (s >> 16) & 0xff] ^ tC[seq.getbyte(i +  3) ^ (s >> 24)       ] ^
                 tB[seq.getbyte(i +  4)                   ] ^ tA[seq.getbyte(i +  5)                   ] ^
                 t9[seq.getbyte(i +  6)                   ] ^ t8[seq.getbyte(i +  7)                   ] ^
                 t7[seq.getbyte(i +  8)                   ] ^ t6[seq.getbyte(i +  9)                   ] ^
@@ -137,13 +143,14 @@ class CRC
                 t1[seq.getbyte(i + 14)                   ] ^ t0[seq.getbyte(i + 15)                   ]
             i += 16
           end
-        else
+        else # when bitsize <= 16
+          # speed improvement for 16-bits CRC
           i = 0
-          while i < iii
-            s = tF[seq.getbyte(i     ) ^ (s      ) & 0xff] ^ tE[seq.getbyte(i +  1) ^ (s >>  8) & 0xff] ^
-                tD[seq.getbyte(i +  2) ^ (s >> 16) & 0xff] ^ tC[seq.getbyte(i +  3) ^ (s >> 24) & 0xff] ^
-                tB[seq.getbyte(i +  4) ^ (s >> 32) & 0xff] ^ tA[seq.getbyte(i +  5) ^ (s >> 40) & 0xff] ^
-                t9[seq.getbyte(i +  6) ^ (s >> 48) & 0xff] ^ t8[seq.getbyte(i +  7) ^ (s >> 56) & 0xff] ^
+          while i < ii16
+            s = tF[seq.getbyte(i     ) ^ (s      ) & 0xff] ^ tE[seq.getbyte(i +  1) ^ (s >>  8)       ] ^
+                tD[seq.getbyte(i +  2)                   ] ^ tC[seq.getbyte(i +  3)                   ] ^
+                tB[seq.getbyte(i +  4)                   ] ^ tA[seq.getbyte(i +  5)                   ] ^
+                t9[seq.getbyte(i +  6)                   ] ^ t8[seq.getbyte(i +  7)                   ] ^
                 t7[seq.getbyte(i +  8)                   ] ^ t6[seq.getbyte(i +  9)                   ] ^
                 t5[seq.getbyte(i + 10)                   ] ^ t4[seq.getbyte(i + 11)                   ] ^
                 t3[seq.getbyte(i + 12)                   ] ^ t2[seq.getbyte(i + 13)                   ] ^
@@ -152,26 +159,65 @@ class CRC
           end
         end
 
-        (iii...ii).each do |n|
+        (i...ii).each do |n|
           s = t0[seq.getbyte(n) ^ s & 0xff] ^ (s >> 8)
         end
 
         s
       else
         Aux.slide_to_head(bitsize, s, polynomial, bitmask) do |s, poly, csh, head, carries|
-          sh = 64 - (head + 1)
-
-          while i < iii
-            s <<= sh
-            s = t7[seq.getbyte(i    ) ^ (s >> 56) & 0xff] ^ t6[seq.getbyte(i + 1) ^ (s >> 48) & 0xff] ^
-                t5[seq.getbyte(i + 2) ^ (s >> 40) & 0xff] ^ t4[seq.getbyte(i + 3) ^ (s >> 32) & 0xff] ^
-                t3[seq.getbyte(i + 4) ^ (s >> 24) & 0xff] ^ t2[seq.getbyte(i + 5) ^ (s >> 16) & 0xff] ^
-                t1[seq.getbyte(i + 6) ^ (s >>  8) & 0xff] ^ t0[seq.getbyte(i + 7) ^ (s >>  0) & 0xff]
-            i += 8
+          case
+          when bitsize > 32
+            sh = 64 - (head + 1)
+
+            while i < ii16
+              s <<= sh
+              s = tF[seq.getbyte(i     ) ^ (s >> 56)       ] ^ tE[seq.getbyte(i +  1) ^ (s >> 48) & 0xff] ^
+                  tD[seq.getbyte(i +  2) ^ (s >> 40) & 0xff] ^ tC[seq.getbyte(i +  3) ^ (s >> 32) & 0xff] ^
+                  tB[seq.getbyte(i +  4) ^ (s >> 24) & 0xff] ^ tA[seq.getbyte(i +  5) ^ (s >> 16) & 0xff] ^
+                  t9[seq.getbyte(i +  6) ^ (s >>  8) & 0xff] ^ t8[seq.getbyte(i +  7) ^ (s      ) & 0xff] ^
+                  t7[seq.getbyte(i +  8)                   ] ^ t6[seq.getbyte(i +  9)                   ] ^
+                  t5[seq.getbyte(i + 10)                   ] ^ t4[seq.getbyte(i + 11)                   ] ^
+                  t3[seq.getbyte(i + 12)                   ] ^ t2[seq.getbyte(i + 13)                   ] ^
+                  t1[seq.getbyte(i + 14)                   ] ^ t0[seq.getbyte(i + 15)                   ]
+              i += 16
+            end
+          when bitsize > 16
+            # speed improvement for 32-bits CRC
+            sh = 32 - (head + 1)
+
+            while i < ii16
+              s <<= sh
+              s = tF[seq.getbyte(i     ) ^ (s >> 24)       ] ^ tE[seq.getbyte(i +  1) ^ (s >> 16) & 0xff] ^
+                  tD[seq.getbyte(i +  2) ^ (s >>  8) & 0xff] ^ tC[seq.getbyte(i +  3) ^ (s      ) & 0xff] ^
+                  tB[seq.getbyte(i +  4)                   ] ^ tA[seq.getbyte(i +  5)                   ] ^
+                  t9[seq.getbyte(i +  6)                   ] ^ t8[seq.getbyte(i +  7)                   ] ^
+                  t7[seq.getbyte(i +  8)                   ] ^ t6[seq.getbyte(i +  9)                   ] ^
+                  t5[seq.getbyte(i + 10)                   ] ^ t4[seq.getbyte(i + 11)                   ] ^
+                  t3[seq.getbyte(i + 12)                   ] ^ t2[seq.getbyte(i + 13)                   ] ^
+                  t1[seq.getbyte(i + 14)                   ] ^ t0[seq.getbyte(i + 15)                   ]
+              i += 16
+            end
+          else # when bitsize <= 16
+            # speed improvement for 16-bits CRC
+            sh = 16 - (head + 1)
+
+            while i < ii16
+              s <<= sh
+              s = tF[seq.getbyte(i     ) ^ (s >>  8)       ] ^ tE[seq.getbyte(i +  1) ^ (s      ) & 0xff] ^
+                  tD[seq.getbyte(i +  2)                   ] ^ tC[seq.getbyte(i +  3)                   ] ^
+                  tB[seq.getbyte(i +  4)                   ] ^ tA[seq.getbyte(i +  5)                   ] ^
+                  t9[seq.getbyte(i +  6)                   ] ^ t8[seq.getbyte(i +  7)                   ] ^
+                  t7[seq.getbyte(i +  8)                   ] ^ t6[seq.getbyte(i +  9)                   ] ^
+                  t5[seq.getbyte(i + 10)                   ] ^ t4[seq.getbyte(i + 11)                   ] ^
+                  t3[seq.getbyte(i + 12)                   ] ^ t2[seq.getbyte(i + 13)                   ] ^
+                  t1[seq.getbyte(i + 14)                   ] ^ t0[seq.getbyte(i + 15)                   ]
+              i += 16
+            end
           end
 
           carries8 = carries >> 7
-          (iii...ii).each do |n|
+          (i...ii).each do |n|
             s = t0[(s >> csh) ^ seq.getbyte(n)] ^ ((carries8 & s) << 8)
           end
           s
@@ -180,10 +226,14 @@ class CRC
     end
 
     def table
-      if reflect_input
-        @table = CRC.build_reflect_table(bitsize, polynomial, slice: 16)
+      if SLICING_SIZE
+        if reflect_input
+          @table = CRC.build_reflect_table(bitsize, polynomial, slice: SLICING_SIZE)
+        else
+          @table = CRC.build_table(bitsize, polynomial, slice: SLICING_SIZE)
+        end
       else
-        @table = CRC.build_table(bitsize, polynomial, slice: 16)
+        @table = nil
       end
 
       singleton_class.class_eval "attr_reader :table"
@@ -193,15 +243,18 @@ class CRC
 
     case ENV["RUBY_CRC_NOFAST"].to_i
     when 0, 1
-      alias update update_with_slice_by_eight
+      alias update update_with_slice_by_16
+      SLICING_SIZE = 16
     when 2
       alias update update_with_lookup_table
+      SLICING_SIZE = 1
     else
       alias update update_with_reference
+      SLICING_SIZE = nil
     end
   end
 
-  module ModuleClass
+  module Calculator
     attr_reader :bitsize, :bitmask, :polynomial, :initial_crc,
                 :reflect_input, :reflect_output, :xor_output, :name
 

data/lib/crc/_combine.rb

@@ -29,7 +29,7 @@
 # >   madler@alumni.caltech.edu
 # >  */
 #
-# Ported by:: dearblue <dearblue@users.osdn.me>
+# Ported by:: dearblue <dearblue@users.noreply.github.com>
 # License:: zlib-style
 #--
 

data/lib/crc/_extensions.rb

@@ -0,0 +1,211 @@
+class CRC
+  module Extensions
+    # refinements
+    # * each_byte
+    # * reverse_each_byte
+    ;
+
+    refine Array do
+      def each_byte
+        return to_enum(:each_byte) unless block_given?
+        each { |ch| yield 0xff & ch }
+        self
+      end
+
+      def reverse_each_byte
+        return to_enum(:reverse_each_byte) unless block_given?
+        reverse_each { |ch| yield 0xff & ch }
+        self
+      end
+    end
+
+    refine BasicObject do
+      def each_byte(&block)
+        Array(self).each_byte(&block)
+      end
+
+      def reverse_each_byte(&block)
+        Array(self).reverse_each_byte(&block)
+      end
+    end
+
+    refine String do
+      def reverse_each_byte
+        return to_enum(:reverse_each_byte) unless block_given?
+        (bytesize - 1).downto(0) { |i| yield getbyte(i) }
+        self
+      end
+    end
+
+    refine NilClass do
+      def each_byte
+        self
+      end
+
+      def reverse_each_byte
+        nil
+      end
+    end
+
+    # refinements:
+    # * convert_internal_state_for
+    # * convert_target_state_for
+    ;
+
+    refine BasicObject do
+      def convert_internal_state_for(crc)
+        raise TypeError, "cant convertion to #{crc.to_s} (for #{inspect})"
+      end
+
+      def convert_target_state_for(crc)
+        raise TypeError, "cant convertion to #{crc.to_s} (for #{inspect})"
+      end
+    end
+
+    refine NilClass do
+      def convert_internal_state_for(crc)
+        crc.setup(crc.initial_crc)
+      end
+
+      def convert_target_state_for(crc)
+        crc.setup(0)
+      end
+    end
+
+    refine String do
+      def convert_internal_state_for(crc)
+        crc.update(self, crc.setup(crc.initial_crc))
+      end
+    end
+
+    refine Integer do
+      def convert_internal_state_for(crc)
+        crc.setup(self)
+      end
+
+      def convert_target_state_for(crc)
+        crc.setup(self)
+      end
+    end
+
+    refine CRC do
+      def convert_internal_state_for(crc)
+        unless crc.variant?(self)
+          raise "not variant crc model (expect #{crc.to_s}, but self is #{inspect})"
+        end
+
+        state
+      end
+
+      def convert_target_state_for(crc)
+        unless crc.variant?(self)
+          raise "not variant crc model (expect #{crc.to_s}, but self is #{inspect})"
+        end
+
+        state
+      end
+    end
+
+    # refinements:
+    # * splitbytes
+    ;
+
+    refine Integer do
+      def splitbytes(bucket, bytes, is_little_endian)
+        if is_little_endian
+          bytes.times { |i| bucket.pushbyte self >> (i * 8) }
+        else
+          (bytes - 1).downto(0) { |i| bucket.pushbyte self >> (i * 8) }
+        end
+
+        bucket
+      end
+    end
+
+    refine String do
+      def pushbyte(ch)
+        self << (0xff & ch).chr(Encoding::BINARY)
+      end
+    end
+
+    refine Array do
+      def pushbyte(ch)
+        self << (0xff & ch)
+      end
+    end
+
+    # refinements:
+    # * bitsize_to_bytesize
+    # * bitsize_to_intsize
+    # * byte_paddingsize
+    # * int_paddingsize
+    ;
+
+    refine Integer do
+      def bitsize_to_bytesize
+        (self + 7) / 8
+      end
+
+      def bitsize_to_intsize
+        bitsize = 8
+        intsize = 1
+        10.times do
+          return intsize if self <= bitsize
+          bitsize <<= 1
+          intsize <<= 1
+        end
+
+        raise "数値が巨大すぎるため、intsize が決定できません - #{inspect}"
+      end
+
+      def byte_paddingsize
+        (bitsize_to_bytesize * 8) - bitsize
+      end
+
+      def int_paddingsize
+        (bitsize_to_intsize * 8) - bitsize
+      end
+    end
+
+    # refinements:
+    # * get_crc_model
+    # * variant_for?
+    ;
+
+    refine BasicObject do
+      def get_crc_model
+        nil
+      end
+
+      def variant_for?(m)
+        false
+      end
+    end
+
+    refine CRC do
+      alias get_crc_model class
+
+      def variant_for?(m)
+        get_crc_model.variant_for?(m)
+      end
+    end
+
+    refine CRC.singleton_class do
+      alias get_crc_model itself
+
+      def variant_for?(m)
+        return false unless m = m.get_crc_model
+
+        if bitsize == m.bitsize &&
+           polynomial == m.polynomial &&
+           reflect_input? == m.reflect_input? &&
+           reflect_output? == m.reflect_output? &&
+           xor_output == m.xor_output
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end