crc 0.3 → 0.4.2

data/lib/crc/_file.rb

@@ -0,0 +1,15 @@
+class CRC
+  def file(path)
+    File.open(path, "rb") do |file|
+      buf = "".b
+      update(buf) while file.read(65536, buf)
+    end
+    self
+  end
+
+  module Calculator
+    def file(path, *args)
+      new(*args).file(path)
+    end
+  end
+end

data/lib/crc/_magic.rb

@@ -0,0 +1,93 @@
+class CRC
+  module Extensions
+    refine Integer do
+      def to_magicdigest_for(m, bytesize = m.bitsize.bitsize_to_bytesize)
+        if m.reflect_input? ^ m.reflect_output?
+          tmp = CRC.bitreflect(self, m.bitsize)
+        else
+          tmp = self
+        end
+
+        if m.reflect_input?
+          magic = tmp.splitbytes("".b, bytesize, true)
+        else
+          tmp <<= ((bytesize * 8) - m.bitsize)
+          magic = tmp.splitbytes("".b, bytesize, false)
+        end
+      end
+    end
+
+    refine String do
+      def to_magicdigest_for(m)
+        bytes = m.bitsize.bitsize_to_bytesize
+        case bytesize
+        when bytes
+          crc = unpack("C*").reduce { |a, ch| (a << 8) | ch }
+        when bytes * 2
+          crc = hex
+        else
+          raise TypeError, "wrong byte size (expect #{bytes} or #{bytes * 2} bytes, but given #{inspect})", caller
+        end
+
+        crc.to_magicdigest_for(m, bytes)
+      end
+    end
+
+    refine CRC do
+      def to_magicdigest_for(m)
+        unless m.variant?(get_crc_model)
+          raise TypeError, "different crc type - #{get_crc_model.inspect} (expect #{m.inspect})", caller
+        end
+
+        magicdigest
+      end
+    end
+
+    refine BasicObject do
+      def to_magicdigest_for(m)
+        raise TypeError, "cant convert type - #{get_crc_model}", caller
+      end
+    end
+
+    refine CRC.singleton_class do
+      def __cached_magic_code__
+        @__cached_magic_code__ = initial_crc.to_magicdigest_for(self).freeze
+        singleton_class.class_eval { attr_reader :__cached_magic_code__ }
+        @__cached_magic_code__
+      end
+    end
+  end
+
+  using CRC::Extensions
+
+  module Calculator
+    def magicnumber
+      @magicnumber = crc(__cached_magic_code__)
+      singleton_class.class_eval { attr_reader :magicnumber }
+      @magicnumber
+    end
+
+    def magic
+      @magic = hexdigest(__cached_magic_code__).freeze
+      singleton_class.class_eval { attr_reader :magic }
+      @magic
+    end
+
+    def magicdigest(seq, crc = nil)
+      crc(seq, crc).to_magicdigest_for(self)
+    end
+
+    #
+    # crc 値を与えると magicdigest へと変換したバイナリデータを返します。
+    #
+    # crc には整数値、digest/hexdigest データ、変種を含む CRC インスタンスを渡すことが出来ます。
+    #
+    def to_magicdigest(crc)
+      crc.to_magicdigest_for(self)
+    end
+  end
+
+  def magicdigest
+    crc.to_magicdigest_for(get_crc_model)
+  end
+end

data/lib/crc/{_modules.rb → _models.rb}

@@ -1,7 +1,7 @@
 #!ruby
 
 #--
-# Author:: dearblue <dearblue@users.osdn.me>
+# Author:: dearblue <dearblue@users.noreply.github.com>
 # License:: Creative Commons License Zero (CC0 / Public Domain)
 #
 # references from:
@@ -19,7 +19,7 @@ class CRC
   LIST = [
     #
     # bit size,  polynomial,              initial crc,
-    #                refrect input,                xor output,
+    #                reflect input,                xor output,
     #                      reflect output,                       crc("123456789"), names...
     #
     [ 1,               0x01,  true,  true,          0,     ~0,               0x01, "CRC-1"],
@@ -78,11 +78,11 @@ class CRC
     [16,             0x6F63, false, false,          0,      0,             0xBDF4, "CRC-16-LJ1200"],
     [16,             0x8005,  true,  true,         ~0,     ~0,             0x44C2, "CRC-16-MAXIM"],
     [16,             0x1021,  true,  true,         ~0,      0,             0x6F91, "CRC-16-MCRF4XX"],
-    [16,             0x1021,  true,  true,     0xB2AA,      0,             0x63D0, "CRC-16-RIELLO"],
+    [16,             0x1021,  true,  true,     0x554D,      0,             0x63D0, "CRC-16-RIELLO"],
     [16,             0xA097, false, false,          0,      0,             0x0FB3, "CRC-16-TELEDISK"],
-    [16,             0x1021,  true,  true,     0x89EC,      0,             0x26B1, "CRC-16-TMS37157"],
+    [16,             0x1021,  true,  true,     0x3791,      0,             0x26B1, "CRC-16-TMS37157"],
     [16,             0x8005,  true,  true,          0,     ~0,             0xB4C8, "CRC-16-USB"],
-    [16,             0x1021,  true,  true,     0xC6C6,      0,             0xBF05, "CRC-16-A", "CRC-A", "CRC-16-ISO/IEC FCD 14443-3"],
+    [16,             0x1021,  true,  true,     0x6363,      0,             0xBF05, "CRC-16-A", "CRC-A", "CRC-16-ISO/IEC FCD 14443-3"],
     [16,             0x1021,  true,  true,          0,      0,             0x2189, "CRC-16-KERMIT", "KERMIT", "CRC-16-CCITT", "CRC-16-CCITT-TRUE", "CRC-CCITT"],
     [16,             0x8005,  true,  true,         ~0,      0,             0x4B37, "CRC-16-MODBUS", "MODBUS"],
     [16,             0x1021,  true,  true,          0,     ~0,             0x906E, "CRC-16-X-25", "X-25", "CRC-16-IBM-SDLC", "CRC-16-ISO-HDLC", "CRC-16-CRC-B", "CRC-B"],
@@ -92,7 +92,7 @@ class CRC
     #[24,         0x005D6DCB, false, false,          0,      0,                nil, "CRC-24"],
     [24,         0x00864CFB, false, false,          0,      0,         0x00CDE703, "CRC-24-Radix-64"],
     [24,         0x00864CFB, false, false, 0x00B704CE,      0,         0x0021CF02, "CRC-24-OPENPGP"],
-    [24,         0x0000065B,  true,  true, 0x00555555,      0,         0x00C25A56, "CRC-24-BLE"],
+    [24,         0x0000065B,  true,  true, 0x00AAAAAA,      0,         0x00C25A56, "CRC-24-BLE"],
     [24,         0x005D6DCB, false, false, 0x00FEDCBA,      0,         0x007979BD, "CRC-24-FLEXRAY-A"],
     [24,         0x005D6DCB, false, false, 0x00ABCDEF,      0,         0x001F23B8, "CRC-24-FLEXRAY-B"],
     [24,         0x00328B63, false, false,          0,     ~0,         0x00B4F3E6, "CRC-24-INTERLAKEN"],
@@ -114,6 +114,7 @@ class CRC
     [32,         0x000000AF, false, false,          0,      0,         0xBD0BE338, "CRC-32-XFER", "XFER"],
     [40,       0x0004820009, false, false,         ~0,     ~0,       0xD4164FC646, "CRC-40-GSM"],
     [64, 0x42F0E1EBA9EA3693,  true,  true,          0,     ~0, 0x995DC9BBDF1939FA, "CRC-64-XZ", "CRC-64"],
+    [64, 0xAD93D23594C935A9,  true,  true,         ~0,      0, 0xCAA717168609F281, "CRC-64-JONES"],
     [64, 0x42F0E1EBA9EA3693, false, false,          0,      0, 0x6C40DF5F0B497347, "CRC-64-ECMA", "CRC-64-ECMA-182"],
     [64, 0x42F0E1EBA9EA3693, false, false,          0,     ~0, 0x62EC59E3F1A4F00A, "CRC-64-WE"],
     [64, 0x000000000000001B,  true,  true,          0,      0, 0x46A5A9388A5BEFFE, "CRC-64-ISO", "CRC-64-ISO-3309"],

data/lib/crc/_shift.rb

@@ -0,0 +1,198 @@
+require_relative "_extensions"
+
+class CRC
+  using Extensions
+
+  module Calculator
+    #
+    # call-seq:
+    #   shiftbits_by_bitbybit(bitset, state) -> state
+    #
+    def shiftbits_by_bitbybit(bitset, state)
+      bitset = Array(bitset)
+
+      if reflect_input?
+        poly = CRC.bitreflect(polynomial, bitsize)
+        bitset.each do |b|
+          state ^= (1 & b)
+          state = (state[0] == 0) ? (state >> 1) : ((state >> 1) ^ poly)
+        end
+
+        state
+      else
+        Aux.slide_to_head(bitsize, state, polynomial, bitmask) do |s, poly, csh, head, carries|
+          bitset.each do |b|
+            s ^= (1 & b) << head
+            s = (s[head] == 0) ? (s << 1) : (((carries & s) << 1) ^ poly)
+          end
+
+          s
+        end
+      end
+    end
+
+    #
+    # call-seq:
+    #   shiftbytes_by_bitbybit(byteset, state)
+    #
+    # standard input の場合は byte は上位ビットから、reflect input の場合は byte は下位ビットから計算されます。
+    #
+    def shiftbytes_by_bitbybit(byteset, state)
+      if reflect_input?
+        poly = CRC.bitreflect(polynomial, bitsize)
+        byteset.each_byte do |b|
+          state ^= 0xff & b
+          8.times do
+            state = (state[0] == 0) ? (state >> 1) : ((state >> 1) ^ poly)
+          end
+        end
+
+        state
+      else
+        Aux.slide_to_head(bitsize, state, polynomial, bitmask) do |s, poly, csh, head, carries|
+          byteset.each_byte do |b|
+            s ^= (0xff & b) << csh
+            8.times do
+              s = (s[head] == 0) ? (s << 1) : (((carries & s) << 1) ^ poly)
+            end
+          end
+
+          s
+        end
+      end
+    end
+
+    #
+    # call-seq:
+    #   unshiftbits_by_bitbybit(bitset, state)
+    #
+    # bitset を与えることで state となるような内部状態を逆算します。
+    #
+    def unshiftbits_by_bitbybit(bitset, state)
+      bitset = Array(bitset)
+
+      if reflect_input?
+        poly = (CRC.bitreflect(polynomial, bitsize) << 1) | 1
+        head = bitsize
+        bitset.reverse_each do |b|
+          state <<= 1
+          state ^= poly unless state[head] == 0
+          state ^= 1 & b
+        end
+
+        state
+      else
+        Aux.slide_to_head(bitsize, state, polynomial, bitmask) do |s, poly, csh, head, carries|
+          headbit = 1 << head
+          lowoff = (head + 1) - bitsize
+          poly = (poly >> 1) | headbit
+          bitset.reverse_each do |b|
+            tmp = s[lowoff]
+            s >>= 1
+            s ^= poly unless tmp == 0
+            s ^= (1 & b) << head
+          end
+
+          s
+        end
+      end
+    end
+
+    #
+    # call-seq:
+    #   unshiftbytes_by_bitbybit(byteset, state)
+    #
+    # byteset を与えることで state となるような内部状態を逆算します。
+    #
+    def unshiftbytes_by_bitbybit(byteset, state)
+      if reflect_input?
+        poly = (CRC.bitreflect(polynomial, bitsize) << 1) | 1
+        head = bitsize
+        byteset.reverse_each_byte do |b|
+          7.downto(0) do |i|
+            state <<= 1
+            state ^= poly unless state[head] == 0
+            state ^= b[i]
+          end
+        end
+
+        state
+      else
+        Aux.slide_to_head(bitsize, state, polynomial, bitmask) do |s, poly, csh, head, carries|
+          headbit = 1 << head
+          lowoff = (head + 1) - bitsize
+          poly = (poly >> 1) | headbit
+          byteset.reverse_each_byte do |b|
+            8.times do |i|
+              tmp = s[lowoff]
+              s >>= 1
+              s ^= poly unless tmp == 0
+              s ^= b[i] << head
+            end
+          end
+
+          s
+        end
+      end
+    end
+
+    def unshift_table
+      if reflect_input?
+        if bitsize < 8
+          pad = 8 - bitsize
+          shift = 0
+        else
+          pad = 0
+          shift = bitsize - 8
+        end
+        poly = ((CRC.bitreflect(polynomial, bitsize) << 1) | 1) << pad
+        head = bitsize + pad
+        @unshift_table = 256.times.map do |ch|
+          state = ch << shift
+          8.times do |i|
+            state <<= 1
+            state ^= poly unless state[head] == 0
+          end
+          state >> pad
+        end
+      else
+        raise NotImplementedError
+      end
+
+      singleton_class.module_eval { attr_reader :unshift_table }
+
+      @unshift_table
+    end
+
+    def unshiftbytes_by_table(byteset, state)
+      if reflect_input?
+        table = unshift_table
+        if bitsize < 8
+          pad = 8 - bitsize
+          shift = 0
+          mask = bitmask
+          byteset.reverse_each_byte do |ch|
+            state = (state << 8) ^ ch
+            state = table[state >> bitsize] ^ (ch & mask)
+          end
+        else
+          shift = bitsize - 8
+          mask = ~(~0 << shift)
+          byteset.reverse_each_byte do |ch|
+            state = table[state >> shift] ^ ((state & mask) << 8)
+            state ^= ch
+          end
+        end
+
+        state
+      else
+        unshiftbytes_by_bitbybit(byteset, state)
+      end
+    end
+
+    alias shiftbits shiftbits_by_bitbybit
+    alias shiftbytes shiftbytes_by_bitbybit
+    alias unshiftbits unshiftbits_by_bitbybit
+    alias unshiftbytes unshiftbytes_by_table
+  end
+end

data/lib/crc/_utils.rb

@@ -0,0 +1,114 @@
+class CRC
+  #
+  # Utilities.
+  #
+  module Utils
+    extend self
+
+    def bitreflect_reference(num, bitsize)
+      n = 0
+      bitsize.times { n <<= 1; n |= (num & 0x01); num >>= 1 }
+      n
+    end
+
+    def bitreflect(num, bitsize)
+      case
+      when bitsize > 128
+        bitreflect_reference(num, bitsize)
+      when bitsize > 64
+        bitreflect128(num) >> (128 - bitsize)
+      when bitsize > 32
+        bitreflect64(num) >> (64 - bitsize)
+      when bitsize > 16
+        bitreflect32(num) >> (32 - bitsize)
+      when bitsize > 8
+        bitreflect16(num) >> (16 - bitsize)
+      else
+        bitreflect8(num) >> (8 - bitsize)
+      end
+    end
+
+    def build_table(bitsize, polynomial, unfreeze = false, slice: 16)
+      bitmask = ~(~0 << bitsize)
+      table = []
+      Aux.slide_to_head(bitsize, 0, bitmask & polynomial, bitmask) do |xx, poly, csh, head, carries, pad|
+        table << (t = [])
+        256.times do |b|
+          b <<= csh
+          8.times { b = (b[head] == 0) ? (b << 1) : (((carries & b) << 1) ^ poly) }
+          t << b
+        end
+        t.freeze unless unfreeze
+
+        carries8 = carries >> 7
+        (1...slice).step do
+          tt = table[-1]
+          table << (t = [])
+          256.times do |b|
+            t << (table[0][tt[b] >> csh] ^ ((carries8 & tt[b]) << 8))
+          end
+          t.freeze unless unfreeze
+        end
+        0
+      end
+      table.freeze unless unfreeze
+      table
+    end
+
+    def build_reflect_table(bitsize, polynomial, unfreeze = false, slice: 16)
+      polynomial = bitreflect(polynomial, bitsize)
+      table = []
+
+      table << (t = [])
+      256.times do |b|
+        8.times { b = (b[0] == 0) ? (b >> 1) : ((b >> 1) ^ polynomial) }
+        t << b
+      end
+      t.freeze unless unfreeze
+
+      (1...slice).step do
+        tt = table[-1]
+        table << (t = [])
+        256.times do |b|
+          t << (table[0][tt[b] & 0xff] ^ (tt[b] >> 8))
+        end
+        t.freeze unless unfreeze
+      end
+
+      table.freeze unless unfreeze
+      table
+    end
+
+    def export_table(table, bitsize, linewidth, indentsize = 2)
+      bitsize0 = bitsize.to_i
+      indent = " " * indentsize.to_i
+      case
+      when bitsize0 > 64 || bitsize0 < 1
+        raise "invalid bitsize (expected to 1..64, but given #{bitsize})"
+      when bitsize0 > 32
+        packformat = "Q>"
+        hexwidth = 16
+      when bitsize0 > 16
+        packformat = "N"
+        hexwidth = 8
+      when bitsize0 > 8
+        packformat = "n"
+        hexwidth = 4
+      else # when bitsize0 > 0
+        packformat = "C"
+        hexwidth = 2
+      end
+      table = table.to_a.pack("#{packformat}*").unpack("H*")[0]
+      table.gsub!(/(?<=\w)(?=\w{#{hexwidth}}{#{linewidth}}+$)/, "\n")
+      table.gsub!(/(?<=\w)(?=\w{#{hexwidth}}+$)/, " ")
+      table.gsub!(/(?<=\w)(?=\s|$)/, ",")
+      table.gsub!(/(?:(?<=^)|(?<=\s))(?=\w)/, "0x")
+      table.gsub!(/^/, "#{indent}  ")
+      <<-EOS
+#{indent}TABLE = [
+#{table}
+#{indent}].freeze
+      EOS
+    end
+  end
+end