crc 0.3.1.1 → 0.4

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

@@ -2,14 +2,14 @@
 
 #--
 # File:: _byruby.rb
-# Author:: dearblue <dearblue@users.osdn.me>
+# Author:: dearblue <dearblue@users.noreply.github.com>
 # License:: Creative Commons License Zero (CC0 / Public Domain)
 #++
 
 #
 # \* \* \* \* \* \* \* \*
 #
-# Pure ruby implemented general CRC generator.
+# Pure ruby implemented general CRC calcurator.
 # It's used slice-by-16 algorithm with byte-order free.
 # This is based on the Intel's slice-by-eight algorithm.
 #
@@ -28,8 +28,7 @@ class CRC
     #
     # 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(initial_crc = nil, size = 0) -> new crc calcurator (CRC instance)
     #
     def new(bitsize, polynomial, initial_crc = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil)
       bitsize = bitsize.to_i
@@ -57,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::Calcurator
       end
     end
 
@@ -259,7 +254,7 @@ class CRC
     end
   end
 
-  module ModuleClass
+  module Calcurator
     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,201 @@
+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
+
+    # 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 module (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 module (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_module
+    # * variant_for?
+    ;
+
+    refine BasicObject do
+      def get_crc_module
+        nil
+      end
+
+      def variant_for?(m)
+        false
+      end
+    end
+
+    refine CRC do
+      alias get_crc_module class
+
+      def variant_for?(m)
+        get_crc_module.variant_for?(m)
+      end
+    end
+
+    refine CRC.singleton_class do
+      alias get_crc_module itself
+
+      def variant_for?(m)
+        return false unless m = m.get_crc_module
+
+        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

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 Calcurator
+    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_module)
+          raise TypeError, "different crc type - #{get_crc_module.inspect} (expect #{m.inspect})", caller
+        end
+
+        magicdigest
+      end
+    end
+
+    refine BasicObject do
+      def to_magicdigest_for(m)
+        raise TypeError, "cant convert type - #{get_crc_module}", 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 Calcurator
+    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_module)
+  end
+end

data/lib/crc/_modules.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:

data/lib/crc/_shift.rb

@@ -0,0 +1,194 @@
+class CRC
+  module Calcurator
+    #
+    # 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