crc 0.3 → 0.4.2

data/gemstub.rb

@@ -1,22 +1,42 @@
-require_relative "lib/crc/version"
+#!ruby
+
+unless File.read("README.md", mode: "rt") =~ /^\s*\*\s*version: (\d+(?:\.\w+)+)/i
+  raise "version number is not found in ``README.md''"
+end
+
+ver = $1
 
 GEMSTUB = Gem::Specification.new do |s|
   s.name = "crc"
-  s.version = CRC::VERSION
-  s.summary = "general CRC generator"
+  s.version = ver
+  s.summary = "generic CRC calculator"
   s.description = <<EOS
-This is a general CRC (Cyclic Redundancy Check) generator for ruby.
-It is written by pure ruby.
-Customization is posible for 1 to 64 bit width, any polynomial primitives, and with/without bit reflection input/output.
+Pure ruby implemented generic CRC (Cyclic Redundancy Check) calculator.
+Customization is posible for 1 to 64 bit width, any polynomials, and with/without bit reflection input/output.
 If you need more speed, please use crc-turbo.
 EOS
-  s.homepage = "https://osdn.jp/projects/rutsubo/"
+  s.homepage = "https://github.com/dearblue/ruby-crc"
   s.licenses = ["BSD-2-Clause", "Zlib", "CC0-1.0"]
   s.author = "dearblue"
-  s.email = "dearblue@users.osdn.me"
+  s.email = "dearblue@users.noreply.github.com"
+
+  s.required_ruby_version = ">= 2.2"
+  s.add_development_dependency "rake", ">= 12"
+end
+
+verfile = "lib/crc/version.rb"
+task "version" => verfile
+file verfile => "README.md" do
+  File.write(verfile, <<-"EOS", mode: "wb")
+#!ruby
 
-  s.required_ruby_version = ">= 2.0"
-  s.add_development_dependency "rake"
+class CRC
+  VERSION = "#{ver}"
 end
+  EOS
+end
+
+LIB << verfile
+LIB.uniq!
 
 EXTRA << "benchmark.rb"

data/lib/crc.rb

@@ -2,26 +2,30 @@
 
 if ENV["RUBY_CRC_NOFAST"].to_i > 0
   require_relative "crc/_byruby"
+  CRC::IMPLEMENT = :ruby
 else
   begin
+    gem "crc-turbo", "~> 0.4.A"
     require File.join("crc", RUBY_VERSION[/\d+\.\d+/], "_turbo.so")
-  rescue LoadError
+    CRC::IMPLEMENT = :turbo
+  rescue LoadError, Gem::MissingSpecVersionError
     require_relative "crc/_byruby"
+    CRC::IMPLEMENT = :ruby
   end
 end
 
 require_relative "crc/version"
 
 #
-# This is a general CRC generator.
+# This is a generic CRC calculator.
 #
-# When you want to use CRC-32 module, there are following ways:
+# When you want to use CRC-32 model, there are following ways:
 #
-# 1. Generate CRC-32'd value at direct:
+# 1. Calculate CRC-32'd value at direct:
 #
 #     CRC.crc32("123456789") # => 3421780262
 #
-# 2. Generate CRC-32'd hex-digest at direct:
+# 2. Calculate CRC-32'd hex-digest at direct:
 #
 #     CRC::CRC32.hexdigest("123456789") # => "CBF43926"
 #
@@ -41,159 +45,31 @@ class CRC
 
   extend Utils
 
-  #
-  # 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
+  require_relative "crc/_extensions"
+  require_relative "crc/_utils"
+  require_relative "crc/_aux"
 
-    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|
-        slice.times do |s|
-          table << (t = [])
-          256.times do |b|
-            r = (s == 0 ? (b << csh) : (table[-2][b]))
-            8.times { r = (r[head] == 0) ? (r << 1) : (((carries & r) << 1) ^ poly) }
-            t << r
-          end
-          t.freeze unless unfreeze
-          t
-        end
-        0
-      end
-      table.freeze unless unfreeze
-      table
-    end
-
-    def build_reflect_table(bitsize, polynomial, unfreeze = false, slice: 16)
-      polynomial = bitreflect(polynomial, bitsize)
-      table = []
-      slice.times do |s|
-        table << (t = [])
-        256.times do |b|
-          r = (s == 0) ? b : table[-2][b]
-          8.times { r = (r[0] == 0) ? (r >> 1) : ((r >> 1) ^ polynomial) }
-          t << r
-        end
-        t.freeze unless unfreeze
-        t
-      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
-
-    #puts export_table(build_table(16, 0x1021), 16, 8); #abort "DEBUG EXIT"
-    #puts export_table(build_table!(32, 0xEDB88320), 32, 8); abort "DEBUG EXIT"
-  end
-
-  extend Utils
-
-  #
-  # 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
+  using Extensions
 
-    #
-    # 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
+  module Calculator
+    def [](seq, *args)
+      c = new(*args)
+      c.update(seq) if seq
+      c
     end
-  end
 
-  module ModuleClass
     def setup(crc = nil)
       crc ||= initial_crc
+      crc ^= xor_output
       crc = CRC.bitreflect(crc, bitsize) if reflect_input? ^ reflect_output?
-      crc ^ xor_output
+      crc & bitmask
     end
 
     alias init setup
 
     def finish(state)
       state = CRC.bitreflect(state, bitsize) if reflect_input? ^ reflect_output?
-      state ^ xor_output
+      state ^ xor_output & bitmask
     end
 
     def crc(seq, crc = nil)
@@ -209,24 +85,7 @@ class CRC
     end
 
     def variant?(obj)
-      case
-      when obj.kind_of?(CRC)
-        mod = obj.class
-      when obj.kind_of?(Class) && obj < CRC
-        mod = obj
-      else
-        return false
-      end
-
-      if bitsize == mod.bitsize &&
-         polynomial == mod.polynomial &&
-         reflect_input? == mod.reflect_input? &&
-         reflect_output? == mod.reflect_output? &&
-         xor_output == mod.xor_output
-        true
-      else
-        false
-      end
+      obj.variant_for?(self)
     end
 
     #
@@ -296,26 +155,22 @@ class CRC
   #
   # call-seq:
   #   initialize(initial_crc = nil, size = 0)
-  #   initialize(seq, initial_crc = nil, size = 0)
   #
-  def initialize(*args)
-    initialize_args(args) do |seq, initial_crc, size|
-      m = self.class
-      @state = m.setup((initial_crc || m.initial_crc).to_i)
-      @size = size.to_i
-      update(seq) if seq
-    end
+  def initialize(initial_crc = nil, size = 0)
+    m = get_crc_model
+    @state = m.setup((initial_crc || m.initial_crc).to_i)
+    @size = size.to_i
   end
 
   def reset(initial_crc = nil, size = 0)
-    m = self.class
+    m = get_crc_model
     @state = m.setup((initial_crc || m.initial_crc).to_i)
     @size = size.to_i
     self
   end
 
   def update(seq)
-    @state = self.class.update(seq, state)
+    @state = get_crc_model.update(seq, state)
     @size += seq.bytesize
     self
   end
@@ -323,20 +178,15 @@ class CRC
   alias << update
 
   def crc
-    self.class.finish(state)
+    get_crc_model.finish(state)
   end
 
   def +(crc2)
-    raise ArgumentError, "not a CRC instance (#{crc2.inspect})" unless crc2.kind_of?(CRC)
-    m1 = self.class
-    m2 = crc2.class
-    unless m1.bitsize == m2.bitsize &&
-           m1.polynomial == m2.polynomial &&
-           m1.reflect_input? == m2.reflect_input? &&
-           m1.reflect_output? == m2.reflect_output? &&
-           # m1.initial_crc == m2.initial_crc &&
-           m1.xor_output == m2.xor_output
-      raise ArgumentError, "different CRC module (#{m1.inspect} and #{m2.inspect})"
+    m1 = get_crc_model
+    m2 = crc2.get_crc_model
+    raise ArgumentError, "not a CRC instance (#{crc2.inspect})" unless m2
+    unless m2.variant_for?(m1)
+      raise ArgumentError, "different CRC model (#{m1.inspect} and #{m2.inspect})"
     end
     m1.new(m1.combine(crc, crc2.crc, crc2.size), size + crc2.size)
   end
@@ -344,15 +194,7 @@ class CRC
   def ==(a)
     case a
     when CRC
-      m1 = self.class
-      m2 = a.class
-      if m1.bitsize == m2.bitsize &&
-         m1.polynomial == m2.polynomial &&
-         m1.reflect_input? == m2.reflect_input? &&
-         m1.reflect_output? == m2.reflect_output? &&
-         # m1.initial_crc == m2.initial_crc &&
-         m1.xor_output == m2.xor_output &&
-         state == a.state
+      if variant_for?(a) && state == a.state
         true
       else
         false
@@ -372,87 +214,70 @@ class CRC
   end
 
   def digest
-    Aux.digest(crc, self.class.bitsize)
+    Aux.digest(crc, get_crc_model.bitsize)
   end
 
   # return digest as internal state
   def digest!
-    Aux.digest(state, self.class.bitsize)
+    Aux.digest(state, get_crc_model.bitsize)
   end
 
   def hexdigest
-    Aux.hexdigest(crc, self.class.bitsize)
+    Aux.hexdigest(crc, get_crc_model.bitsize)
   end
 
   # return hex-digest as internal state
   def hexdigest!
-    Aux.hexdigest(state, self.class.bitsize)
+    Aux.hexdigest(state, get_crc_model.bitsize)
   end
 
   alias to_str hexdigest
   alias to_s hexdigest
 
   def inspect
-    "\#<#{self.class}:#{hexdigest}>"
+    "\#<#{get_crc_model}:#{hexdigest}>"
   end
 
   def pretty_inspect(q)
     q.text inspect
   end
 
-  private
-  def initialize_args(args)
-    case args.size
-    when 0
-      yield nil, nil, 0
-    when 1
-      if args[0].kind_of?(String)
-        yield args[0], nil, 0
-      else
-        yield nil, args[0], 0
-      end
-    when 2
-      if args[0].kind_of?(String)
-        yield args[0], args[1], 0
-      else
-        yield nil, args[0], args[1].to_i
-      end
-    when 3
-      yield args[0], args[1], args[2].to_i
-    else
-      raise ArgumentError, "wrong argument size (given #{args.size}, expect 0..3)"
-    end
-  end
-
-  MODULE_TABLE = {}
+  MODEL_TABLE = {}
 
   class << self
-    def lookup(modulename)
-      modulename1 = modulename.to_s.gsub(/[\W_]+/, "")
-      modulename1.downcase!
-      MODULE_TABLE[modulename1] or raise NameError, "modulename is not matched (for #{modulename})"
+    def lookup(modelname)
+      modelname1 = modelname.to_s.gsub(/[\W_]+/, "")
+      modelname1.downcase!
+      MODEL_TABLE[modelname1] or raise NameError, "modelname is not matched (for #{modelname})"
     end
 
     alias [] lookup
 
-    def crc(modulename, seq, crc = nil)
-      lookup(modulename).crc(seq, crc)
+    def crc(modelname, seq, crc = nil)
+      lookup(modelname).crc(seq, crc)
     end
 
-    def digest(modulename, seq, crc = nil)
-      lookup(modulename).digest(seq, crc)
+    def digest(modelname, seq, crc = nil)
+      lookup(modelname).digest(seq, crc)
     end
 
-    def hexdigest(modulename, seq, crc = nil)
-      lookup(modulename).hexdigest(seq, crc)
+    def hexdigest(modelname, seq, crc = nil)
+      lookup(modelname).hexdigest(seq, crc)
     end
   end
 
-  require_relative "crc/_modules"
+  # NOTE: "Calcurator" は typo ですが、後方互換のため一時的に残します。
+  # TODO: CRC::Calcurator はいずれ削除されます。
+  CRC::Calcurator = CRC::Calculator
+
+  require_relative "crc/_models"
   require_relative "crc/_combine"
+  require_relative "crc/_shift"
+  require_relative "crc/_magic"
+  require_relative "crc/_file"
 
   #
-  # Create CRC module classes.
+  # Create CRC model classes.
   #
   LIST.each do |bitsize, polynomial, refin, refout, initial_crc, xor, check, *names|
     names.flatten!
@@ -463,10 +288,10 @@ class CRC
 
     names.each do |nm|
       nm1 = nm.downcase.gsub(/[\W_]+/, "")
-      if MODULE_TABLE.key?(nm1)
-        raise NameError, "collision crc-module name: #{nm} (#{crc::GENERATOR} and #{MODULE_TABLE[nm1]::GENERATOR})"
+      if MODEL_TABLE.key?(nm1)
+        raise NameError, "collision crc-model name: #{nm} ({#{crc.to_str}} and {#{MODEL_TABLE[nm1].to_str}})"
       end
-      MODULE_TABLE[nm1] = crc
+      MODEL_TABLE[nm1] = crc
 
       name = nm.sub(/(?<=\bCRC)-(?=\d+)/, "").gsub(/[\W]+/, "_")
       const_set(name, crc)
@@ -484,23 +309,4 @@ class CRC
     check = Integer(check.to_i) if check
     crc.const_set :CHECK, check
   end
-
-  if $0 == __FILE__
-    $stderr.puts "#{__FILE__}:#{__LINE__}: SELF CHECK for CRC modules (#{File.basename($".grep(/_(?:byruby|turbo)/)[0]||"")})\n"
-    MODULE_TABLE.values.uniq.each do |crc|
-      check = crc::CHECK
-      checked = crc.crc("123456789")
-      case check
-      when nil
-        $stderr.puts "| %20s(\"123456789\") = %16X (check only)\n" % [crc.name, checked]
-      when checked
-        ;
-      else
-        $stderr.puts "| %20s(\"123456789\") = %16X (expect to %X)\n" % [crc.name, checked, check]
-      end
-    end
-    $stderr.puts "#{__FILE__}:#{__LINE__}: DONE SELF CHECK\n"
-
-    exit
-  end
 end