crc 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bee58adf97d048655d45b3f33a14781b150638c7
+  data.tar.gz: bd49389a8b03124937b87c7a09deaf1fd03b3f8e
+SHA512:
+  metadata.gz: ba1a3e68cef316f5e46db132c8fceeb66bace335427ec49b01987f87bb12b74ab7409649b5240baa4876231fd52da93f999fb6fdb01fa1f56657a9183f3b03fd
+  data.tar.gz: 707b71a8fcd2dfe0593ce3d94b4fbd3b2265c202e67d6e704c39c758c275e1386fe14626090c8ace254c78edb6e7ff03846b8ea551bf4335e110c1eef78f9a41

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2016, dearblue. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,67 @@
+
+# crc - CRC generator for ruby
+
+This is a general CRC (Cyclic Redundancy Check) generator for ruby.
+
+It is written by pure ruby with based on slice-by-eight algorithm (byte-order-free slice-by-16 algorithm).
+
+Included built-in CRC modules are CRC-32, CRC-64-ECMA, CRC-64-ISO, CRC-16-CCITT, CRC-16-IBM, CRC-8, CRC-5-USB, CRC-5-EPC and more.
+
+And your defined CRC modules to use.
+
+This is slower than x95+ of zlib/crc32, and slower than x135+ of extlzma/crc32 on FreeBSD 10.3R amd64.
+
+If you need more speed, please use crc-turbo.
+
+
+## SUMMARY
+
+  * package name: crc
+  * author: dearblue (mailto:dearblue@users.osdn.me)
+  * report issue to: <https://osdn.jp/projects/rutsubo/ticket/>
+  * how to install: ``gem install crc``
+  * version: 0.1
+  * release quality: thechnical preview
+  * licensing: BSD-2-Clause
+  * dependency gems: none
+  * dependency external c libraries: none
+  * bundled external c libraries: none
+
+## FEATURES
+
+  * ``CRC.crc32(seq, init = 0) -> crc-32 integer`` (likely as ``Zlib.crc32``)
+  * ``CRC::CRC32.crc(seq, init = 0) -> crc-32 integer`` (likely as ``Zlib.crc32``)
+  * ``CRC::CRC32.digest(seq, init = 0) -> crc-32 digest`` (likely as ``Digest::XXXX.digest``)
+  * ``CRC::CRC32.hexdigest(seq, init = 0) -> crc-32 hex-digest`` (likely as ``Digest::XXXX.hexdigest``)
+  * ``CRC::CRC32.new(init = 0) -> crc-32 context`` (likely as ``Digest::XXXX.new``)
+  * ``CRC::CRC32#update(seq) -> self`` (likely as ``Digest::XXXX#update``)
+  * ``CRC::CRC32#finish -> crc-32 integer`` (likely as ``Digest::XXXX#finish``)
+  * ``CRC.crc("crc-32", seq, init = 0) -> crc-32 integer``
+  * ``CRC.digest("crc-32", seq, init = 0) -> crc-32 digest``
+  * ``CRC.hexdigest("crc-32", seq, init = 0) -> crc-32 hex-digest``
+
+----
+
+  * ``CRC.create_module(bitsize, poly, init_state, refin, refout, xorout) -> new crc module class``
+
+    ``` ruby:ruby
+    MyCRC32 = CRC.create_module(32, 0x04C11DB7)
+    p MyCRC32.class  # => Class
+    p MyCRC32.hexdigest("123456789")  # => "CBF43926"
+    ```
+
+
+## BUILD-IN CRC MODULES
+
+``` shell:shell
+% ruby -rcrc -e 'puts CRC::MODULE_TABLE.values.uniq.map { |m| m::TRAITS.name }.join(", ")'
+```
+
+CRC-1, CRC-3-ROHC, CRC-4-ITU, CRC-5-EPC, CRC-5-ITU, CRC-5-USB, CRC-6-CDMA2000-A, CRC-6-CDMA2000-B, CRC-6-DARC, CRC-6-ITU, CRC-7, CRC-7-MVB, CRC-8, CRC-8-CCITT, CRC-8-Dallas/Maxim, CRC-8-DARC, CRC-8-SAE, CRC-8-WCDMA, CRC-10, CRC-10-CDMA2000, CRC-11, CRC-12, CRC-12-CDMA2000, CRC-13-BBC, CRC-14-DARC, CRC-15-CAN, CRC-15-MPT1327, Chakravarty, CRC-16-ARINC, CRC-16-CCITT, CRC-16-CDMA2000, CRC-16-DECT, CRC-16-T10-DIF, CRC-16-DNP, CRC-16-IBM, CRC-16-LZH, CRC-17-CAN, CRC-21-CAN, CRC-24, CRC-24-Radix-64, CRC-30, CRC-32, CRC-32C, CRC-32K, CRC-32K2, CRC-32Q, CRC-40-GSM, CRC-64-ECMA, CRC-64-ISO
+
+
+## ENVIRONMENT VARIABLES FOR BEHAVIOR
+
+  * ``RUBY_CRC_NOFAST=1``: Force use ruby implementation with slice-by-16 algorithm. Not used "crc-turbo".
+  * ``RUBY_CRC_NOFAST=2``: Switch to lookup table algorithm from slice-by-16 algorithm. Slower to about 52% (when CRC-32).
+  * ``RUBY_CRC_NOFAST=3``: Switch to reference algorithm from slice-by-16 algorithm. Slower to about 7% (when CRC-32).

data/Rakefile

@@ -0,0 +1,212 @@
+
+require "pathname"
+require "rake/clean"
+
+docnames = "{README,LICENSE,CHANGELOG,Changelog,HISTORY}"
+doctypes = "{,.txt,.rd,.rdoc,.md,.markdown}"
+cexttypes = "{c,C,cc,cxx,cpp,h,H,hh}"
+
+DOC = FileList["#{docnames}{,.ja}#{doctypes}"] +
+      FileList["{contrib,ext}/**/#{docnames}{,.ja}#{doctypes}"] +
+      FileList["ext/**/*.#{cexttypes}"]
+EXT = FileList["ext/**/*"]
+BIN = FileList["bin/*"]
+LIB = FileList["lib/**/*.rb"]
+SPEC = FileList["spec/**/*"]
+TEST = FileList["test/**/*"]
+EXAMPLE = FileList["examples/**/*"]
+GEMSTUB_SRC = "gemstub.rb"
+RAKEFILE = [File.basename(__FILE__), GEMSTUB_SRC]
+EXTRA = []
+EXTCONF = FileList["ext/**/extconf.rb"]
+EXTCONF.reject! { |n| !File.file?(n) }
+EXTMAP = {}
+
+load GEMSTUB_SRC
+
+EXTMAP.dup.each_pair do |dir, name|
+  EXTMAP[Pathname.new(dir).cleanpath.to_s] = Pathname.new(name).cleanpath.to_s
+end
+
+GEMSTUB.extensions += EXTCONF
+GEMSTUB.executables += FileList["bin/*"].map { |n| File.basename n }
+GEMSTUB.executables.sort!
+
+PACKAGENAME = "#{GEMSTUB.name}-#{GEMSTUB.version}"
+GEMFILE = "#{PACKAGENAME}.gem"
+GEMSPEC = "#{PACKAGENAME}.gemspec"
+
+GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + EXTRA
+GEMSTUB.files.sort!
+if GEMSTUB.rdoc_options.nil? || GEMSTUB.rdoc_options.empty?
+  readme = %W(.md .markdown .rd .rdoc .txt #{""}).map { |ext| "README#{ext}" }.find { |m| DOC.find { |n| n == m } }
+  GEMSTUB.rdoc_options = %w(--charset UTF-8) + (readme ? %W(-m #{readme}) : [])
+end
+GEMSTUB.extra_rdoc_files += DOC + LIB + EXT.reject { |n| n.include?("/externals/") || !%w(.h .hh .c .cc .cpp .cxx).include?(File.extname(n)) }
+GEMSTUB.extra_rdoc_files.sort!
+
+GEMSTUB_TRYOUT = GEMSTUB.dup
+GEMSTUB_TRYOUT.version = "#{GEMSTUB.version}#{Time.now.strftime(".TRYOUT.%Y%m%d.%H%M%S")}"
+PACKAGENAME_TRYOUT = "#{GEMSTUB.name}-#{GEMSTUB_TRYOUT.version}"
+GEMFILE_TRYOUT = "#{PACKAGENAME_TRYOUT}.gem"
+GEMSPEC_TRYOUT = "#{PACKAGENAME_TRYOUT}.gemspec"
+
+CLEAN << GEMSPEC << GEMSPEC_TRYOUT
+CLOBBER << GEMFILE
+
+task :default => :tryout do
+  $stderr.puts <<-EOS
+#{__FILE__}:#{__LINE__}:
+\ttype ``rake release'' to build release package.
+  EOS
+end
+
+desc "build tryout package"
+task :tryout
+
+desc "build release package"
+task :release => :all
+
+unless EXTCONF.empty?
+  RUBYSET ||= (ENV["RUBYSET"] || "").split(",")
+
+  if RUBYSET.nil? || RUBYSET.empty?
+    $stderr.puts <<-EOS
+#{__FILE__}:
+|
+| If you want binary gem package, launch rake with ``RUBYSET`` enviroment
+| variable for set ruby interpreters by comma separated.
+|
+|   e.g.) $ rake RUBYSET=ruby
+|     or) $ rake RUBYSET=ruby21,ruby22,ruby23
+|
+    EOS
+  else
+    platforms = RUBYSET.map { |ruby| `#{ruby} --disable-gems -e "puts RUBY_PLATFORM"`.chomp }
+    platforms1 = platforms.uniq
+    unless platforms1.size == 1 && !platforms1[0].empty?
+      abort <<-EOS
+#{__FILE__}:#{__LINE__}: different platforms:
+#{RUBYSET.zip(platforms).map { |ruby, platform| "%24s => %s" % [ruby, platform] }.join("\n")}
+ABORTED.
+      EOS
+    end
+    PLATFORM = platforms1[0]
+
+    RUBY_VERSIONS = RUBYSET.map do |ruby|
+      ver = `#{ruby} --disable-gems -e "puts RUBY_VERSION"`.slice(/\d+\.\d+/)
+      raise "failed ruby checking - ``#{ruby}''" unless $?.success?
+      [ver, ruby]
+    end
+
+    SOFILES_SET = RUBY_VERSIONS.map { |(ver, ruby)|
+      EXTCONF.map { |extconf|
+        extdir = Pathname.new(extconf).cleanpath.dirname.to_s
+        case
+        when soname = EXTMAP[extdir.sub(/^ext\//i, "")]
+          soname = soname.sub(/\.so$/i, "")
+        when extdir == "ext" || extdir == "."
+          soname = GEMSTUB.name
+        else
+          soname = File.basename(extdir)
+        end
+
+        [ruby, File.join("lib", "#{soname.sub(/(?<=\/)|^(?!.*\/)/, "#{ver}/")}.so"), extconf]
+      }
+    }.flatten(1)
+    SOFILES = SOFILES_SET.map { |(ruby, sopath, extconf)| sopath }
+
+    GEMSTUB_NATIVE = GEMSTUB.dup
+    GEMSTUB_NATIVE.files += SOFILES
+    GEMSTUB_NATIVE.platform = Gem::Platform.new(PLATFORM).to_s
+    GEMSTUB_NATIVE.extensions.clear
+    GEMFILE_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.version}-#{GEMSTUB_NATIVE.platform}.gem"
+    GEMSPEC_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.platform}.gemspec"
+
+    task :all => ["native-gem", GEMFILE]
+
+    desc "build binary gem package"
+    task "native-gem" => GEMFILE_NATIVE
+
+    desc "generate binary gemspec"
+    task "native-gemspec" => GEMSPEC_NATIVE
+
+    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
+      sh "gem build #{GEMSPEC_NATIVE}"
+    end
+
+    file GEMSPEC_NATIVE => RAKEFILE do
+      File.write(GEMSPEC_NATIVE, GEMSTUB_NATIVE.to_ruby, mode: "wb")
+    end
+
+    desc "build c-extension libraries"
+    task "sofiles" => SOFILES
+
+    SOFILES_SET.each do |(ruby, soname, extconf)|
+      sodir = File.dirname(soname)
+      makefile = File.join(sodir, "Makefile")
+
+      CLEAN << GEMSPEC_NATIVE << sodir
+      CLOBBER << GEMFILE_NATIVE
+
+      directory sodir
+
+      desc "generate Makefile for binary extension library"
+      file makefile => [sodir, extconf] do
+        rel_extconf = Pathname.new(extconf).relative_path_from(Pathname.new(sodir)).to_s
+        cd sodir do
+          sh *%W"#{ruby} #{rel_extconf} --ruby=#{ruby} #{ENV["EXTCONF"]}"
+        end
+      end
+
+      desc "build binary extension library"
+      file soname => [makefile] + EXT do
+        cd sodir do
+          sh "make"
+        end
+      end
+    end
+  end
+end
+
+
+task :all => GEMFILE
+task :tryout => GEMFILE_TRYOUT
+
+desc "generate local rdoc"
+task :rdoc => DOC + LIB do
+  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + LIB)
+end
+
+desc "launch rspec"
+task rspec: :all do
+  sh "rspec"
+end
+
+desc "build gem package"
+task gem: GEMFILE
+
+desc "generate gemspec"
+task gemspec: GEMSPEC
+
+desc "print package name"
+task "package-name" do
+  puts PACKAGENAME
+end
+
+file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC] do
+  sh "gem build #{GEMSPEC}"
+end
+
+file GEMFILE_TRYOUT => DOC + EXT + EXTCONF + BIN + LIB + SPEC + TEST + EXAMPLE + RAKEFILE + [GEMSPEC_TRYOUT] do
+#file GEMFILE_TRYOUT do
+  sh "gem build #{GEMSPEC_TRYOUT}"
+end
+
+file GEMSPEC => RAKEFILE do
+  File.write(GEMSPEC, GEMSTUB.to_ruby, mode: "wb")
+end
+
+file GEMSPEC_TRYOUT => RAKEFILE do
+  File.write(GEMSPEC_TRYOUT, GEMSTUB_TRYOUT.to_ruby, mode: "wb")
+end

data/benchmark.rb

@@ -0,0 +1,45 @@
+#
+# Only this code to the PUBLIC DOMAIN.
+#
+
+require "benchmark"
+#require "securerandom"
+require "zlib"
+require "crc"
+begin; require "extlzma"; rescue LoadError; no_extlzma = true; end
+begin; require "digest/crc"; rescue LoadError; no_digest_crc = true; end
+
+def measure(generator_name)
+  print "  * measuring for #{generator_name}..."
+  $stdout.flush
+  realms = 5.times.map do
+    real = (Benchmark.measure { yield }.real * 1000)
+    print " #{real.ceil} ms."
+    $stdout.flush
+    real
+  end.min
+  puts " (#{realms.ceil} ms.)\n"
+  [generator_name, realms]
+end
+
+size = 20
+puts " ** preparing #{size} MiB data...\n"
+#s = SecureRandom.random_bytes(size << 20)
+s = "0" * (size << 20)
+
+crc = measure("ruby-crc/crc32") { CRC.crc32(s) }[1]
+comparisons = []
+comparisons << measure("zlib/crc-32") { Zlib.crc32(s) }
+comparisons << measure("extlzma/crc-32") { LZMA.crc32(s) } unless no_extlzma
+comparisons << measure("digest/crc-32") { Digest::CRC32.digest(s) } unless no_digest_crc
+comparisons << measure("ruby-crc/crc-64") { CRC.crc64(s) }
+comparisons << measure("extlzma/crc-64") { LZMA.crc64(s) } unless no_extlzma
+
+puts <<'EOS'
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+                                          (slowly at over 1.0)
+EOS
+
+comparisons.each do |name, meas|
+  puts "%24s : ruby-crc/crc32 = %10.5f : 1.0\n" % [name, crc / meas]
+end

data/gemstub.rb

@@ -0,0 +1,21 @@
+GEMSTUB = Gem::Specification.new do |s|
+  s.name = "crc"
+  s.version = "0.1"
+  s.summary = "general CRC generator"
+  s.description = <<EOS
+This is a general CRC (Cyclic Redundancy Check) generator for ruby.
+It is written by pure ruby with based on slice-by-eight algorithm (byte-order-free slice-by-16 algorithm).
+Included built-in CRC modules are CRC-32, CRC-64-ECMA, CRC-64-ISO, CRC-16-CCITT, CRC-16-IBM, CRC-8, CRC-5-USB, CRC-5-EPC and more.
+And your defined CRC modules to use.
+If you need more speed, please use crc-turbo.
+EOS
+  s.homepage = "https://osdn.jp/projects/rutsubo/"
+  s.license = "BSD-2-Clause"
+  s.author = "dearblue"
+  s.email = "dearblue@users.osdn.me"
+
+  s.required_ruby_version = ">= 2.0"
+  s.add_development_dependency "rake", "~> 11.0"
+end
+
+EXTRA << "benchmark.rb"

data/lib/crc.rb

@@ -0,0 +1,405 @@
+#!ruby
+
+if ENV["RUBY_CRC_NOFAST"].to_i > 0
+  require_relative "crc/_byruby"
+else
+  begin
+    require File.join("crc", RUBY_VERSION[/\d+\.\d+/], "_turbo.so")
+  rescue LoadError
+    require_relative "crc/_byruby"
+  end
+end
+
+module CRC
+  CRC = self
+
+  extend Utils
+
+  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 > 64
+        bitreflect_reference(num, 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
+
+    if false
+      20.times do
+        n = rand(1 << 62)
+        bitsize = rand(64) + 1
+        a = bitreflect_reference(n, bitsize)
+        b = bitreflect(n, bitsize)
+        puts "0x%016X (%2d) => 0x%016X, 0x%016X (%s)" % [n, bitsize, a, b, (a == b)]
+      end
+      puts
+      require "benchmark"
+      Benchmark.bm(24) do |bm|
+        t = 1 << 16
+        4.times do
+          bm.report("reference(-1, 8)") { t.times { bitreflect_reference(-1, 8) } }
+          bm.report("reference(-1, 16)") { t.times { bitreflect_reference(-1, 16) } }
+          bm.report("reference(-1, 24)") { t.times { bitreflect_reference(-1, 24) } }
+          bm.report("reference(-1, 32)") { t.times { bitreflect_reference(-1, 32) } }
+          bm.report("reference(-1, 64)") { t.times { bitreflect_reference(-1, 64) } }
+          bm.report("bitreflect(-1, 8)") { t.times { bitreflect(-1, 8) } }
+          bm.report("bitreflect(-1, 16)") { t.times { bitreflect(-1, 16) } }
+          bm.report("bitreflect(-1, 24)") { t.times { bitreflect(-1, 24) } }
+          bm.report("bitreflect(-1, 32)") { t.times { bitreflect(-1, 32) } }
+          bm.report("bitreflect(-1, 64)") { t.times { bitreflect(-1, 64) } }
+          puts
+        end
+      end
+      abort "TEST ABORT"
+    end
+
+    def build_table(bitsize, polynomial)
+      bitmask = ~(~0 << bitsize)
+      carrydown = bitmask >> 1
+      polynomial = bitmask & polynomial
+      table = []
+      head = 7
+      256.times do |i|
+        8.times { i = (i[head] == 0) ? (i << 1) : (((i & carrydown) << 1) ^ polynomial) }
+        table << i
+      end
+
+      table.freeze
+    end
+
+    def build_table8(bitsize, polynomial, unfreeze = false)
+      bitmask = ~(~0 << bitsize)
+      table = []
+      Aux.slide_to_head(bitsize, 0, bitmask & polynomial, bitmask) do |xx, poly, csh, head, carries, pad|
+        8.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_table!(bitsize, polynomial)
+      polynomial = bitreflect(polynomial, bitsize)
+      table = []
+      256.times do |i|
+        8.times { i = (i[0] == 0) ? (i >> 1) : ((i >> 1) ^ polynomial) }
+        table << i
+      end
+
+      table.freeze
+    end
+
+    def build_table8!(bitsize, polynomial, unfreeze = false)
+      polynomial = bitreflect(polynomial, bitsize)
+      table = []
+      16.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
+
+  module Aux
+    def self.DIGEST(state, bitsize)
+      bits = (bitsize + 7) / 8 * 8
+      seq = "".b
+      (bits - 8).step(0, -8) { |i| seq << yield((state >> i) & 0xff) }
+      seq
+    end
+
+    def self.digest(state, bitsize)
+      DIGEST(state, bitsize) { |n| [n].pack("C") }
+    end
+
+    def self.hexdigest(state, bitsize)
+      DIGEST(state, 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
+
+  class Generator
+    def crc(seq, state = nil)
+      finish(update(seq, setup(state)))
+    end
+
+    def setup(state = nil)
+      state ||= initial_state
+      state ^= xor_output
+      state = CRC.bitreflect(state, bitsize) if reflect_input ^ reflect_output
+      state
+    end
+
+    def finish(state)
+      state = CRC.bitreflect(state, bitsize) if reflect_input ^ reflect_output
+      state ^ xor_output
+    end
+
+    def digest(seq, state = nil)
+      Aux.digest(crc(seq, state), bitsize)
+    end
+
+    def hexdigest(seq, state = nil)
+      Aux.hexdigest(crc(seq, state), bitsize)
+    end
+
+    def to_s
+      case
+      when bitsize > 64 then width = 20
+      when bitsize > 32 then width = 16
+      when bitsize > 16 then width =  8
+      when bitsize >  8 then width =  4
+      else                   width =  2
+      end
+
+      if reflect_input
+        ref = ", reflect-in#{reflect_output ? "/out" : ""}"
+      else
+        ref = reflect_output ? ", reflect-out" : ""
+      end
+
+      case initial_state
+      when 0        then init = "0"
+      when bitmask  then init = "~0"
+      when 1        then init = "1"
+      else               init = "0x%0#{width}X" % initial_state
+      end
+
+      case xor_output
+      when 0        then xor = "0"
+      when bitmask  then xor = "~0"
+      when 1        then xor = "1"
+      else               xor = "0x%0#{width}X" % xor_output
+      end
+
+      if nm = name
+        "#{nm}(CRC-%d-0x%0#{width}X init=%s%s, xor=%s)" % [bitsize, polynomial, init, ref, xor]
+      else
+        "(CRC-%d-0x%0#{width}X init=%s%s, xor=%s)" % [bitsize, polynomial, init, ref, xor]
+      end
+    end
+
+    def inspect
+      "\#<#{self.class} #{to_s}>"
+    end
+
+    def pretty_inspect(q)
+      q.text inspect
+    end
+  end
+
+  class BasicCRC < Struct.new(:internal_state, :initial_state)
+    BasicStruct = superclass
+
+    class BasicStruct
+      alias state! internal_state
+      alias set_state! internal_state=
+    end
+
+    def initialize(initial_state = nil)
+      generator = self.class::GENERATOR
+      initial_state ||= generator.initial_state
+      super generator.setup(initial_state), initial_state
+    end
+
+    def reset(initial_state = self.initial_state)
+      generator = self.class::GENERATOR
+      initial_state ||= generator.initial_state
+      set_state! generator.setup(initial_state)
+      self.initial_state = initial_state
+      self
+    end
+
+    def update(seq)
+      set_state! self.class::GENERATOR.update!(seq, state!)
+      self
+    end
+
+    alias << update
+
+    def finish
+      self.class::GENERATOR.finish(state!)
+    end
+
+    alias state finish
+
+    def digest
+      Aux.DIGEST(state, self.class::GENERATOR.bitsize) { |n| [n].pack("C") }
+    end
+
+    # ビット反転せずに値を返す
+    def digest!
+      Aux.DIGEST(state!, self.class::GENERATOR.bitsize) { |n| [n].pack("C") }
+    end
+
+    def hexdigest
+      Aux.DIGEST(state, self.class::GENERATOR.bitsize) { |n| "%02X" % n }
+    end
+
+    # ビット反転せずに値を返す
+    def hexdigest!
+      Aux.DIGEST(state!, self.class::GENERATOR.bitsize) { |n| "%02X" % n }
+    end
+
+    alias to_str hexdigest
+    alias to_s hexdigest
+
+    def inspect
+      "\#<#{self.class}:#{hexdigest}>"
+    end
+
+    def pretty_inspect(q)
+      q.text inspect
+    end
+
+    class << self
+      def inspect
+
+        if const_defined?(:GENERATOR)
+          if nm = name
+            "#{nm}(#{self::GENERATOR.to_s})"
+          else
+            super.sub(/(?=\>$)/) { " #{self::GENERATOR.to_s}" }
+          end
+        else
+          super
+        end
+      end
+
+      def pretty_inspect(q)
+        q.text inspect
+      end
+
+      def crc(seq, state = nil)
+        self::GENERATOR.crc(seq, state)
+      end
+
+      def digest(seq, state = nil)
+        Aux.digest(self::GENERATOR.crc(seq, state), self::GENERATOR.bitsize)
+      end
+
+      def hexdigest(seq, state = nil)
+        Aux.hexdigest(self::GENERATOR.crc(seq, state), self::GENERATOR.bitsize)
+      end
+    end
+  end
+
+  MODULE_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})"
+    end
+
+    alias [] lookup
+
+    def crc(modulename, seq, state = nil)
+      lookup(modulename).crc(seq, state)
+    end
+
+    def digest(modulename, seq, state = nil)
+      lookup(modulename).digest(seq, state)
+    end
+
+    def hexdigest(modulename, seq, state = nil)
+      lookup(modulename).hexdigest(seq, state)
+    end
+
+    def create_module(bitsize, polynomial, initial_state = 0, refin = true, refout = true, xor = ~0, name = nil)
+      generator = Generator.new(bitsize, polynomial, initial_state, refin, refout, xor, name)
+      crc = Class.new(BasicCRC)
+      crc.const_set :GENERATOR, generator
+      crc
+    end
+  end
+
+  SELF_TEST = ($0 == __FILE__) ? true : false
+end
+
+require_relative "crc/_modules"

data/lib/crc/_byruby.rb

@@ -0,0 +1,226 @@
+#--
+# Author:: dearblue <dearblue@users.osdn.me>
+# License:: BSD-2-Clause
+#++
+
+#
+# Ruby implemented CRC generator.
+# It's Based on the Intel's slice-by-eight algorithm (but byte-order-free).
+#
+# It's faster than about 50% (CRC-32) and about 30% (CRC-64) of
+# lookup-table algorithm. But need more memory.
+#
+# reference:
+# * http://www.intel.com/technology/comms/perfnet/download/CRC_generators.pdf
+# * xz-utils (src/liblzma/check/crc32_fast.c, 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.
+#
+module CRC
+  module Utils
+    def bitreflect8(n)
+      n    = n.to_i
+      n    = ((n & 0x55) <<  1) | ((n >>  1) & 0x55)
+      n    = ((n & 0x33) <<  2) | ((n >>  2) & 0x33)
+      return ((n & 0x0f) <<  4) |  (n >>  4) # 0x0f
+    end
+
+    def bitreflect16(n)
+      n    = n.to_i
+      n    = ((n & 0x5555) <<  1) | ((n >>  1) & 0x5555)
+      n    = ((n & 0x3333) <<  2) | ((n >>  2) & 0x3333)
+      n    = ((n & 0x0f0f) <<  4) | ((n >>  4) & 0x0f0f)
+      return ((n & 0x00ff) <<  8) |  (n >>  8) # 0x00ff
+    end
+
+    def bitreflect32(n)
+      n    = n.to_i
+      n    = ((n & 0x55555555) <<  1) | ((n >>  1) & 0x55555555)
+      n    = ((n & 0x33333333) <<  2) | ((n >>  2) & 0x33333333)
+      n    = ((n & 0x0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f)
+      n    = ((n & 0x00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff)
+      return ((n & 0x0000ffff) << 16) |  (n >> 16) # 0x0000ffff
+    end
+
+    def bitreflect64(n)
+      n    = n.to_i
+      n    = ((n & 0x5555555555555555) <<  1) | ((n >>  1) & 0x5555555555555555)
+      n    = ((n & 0x3333333333333333) <<  2) | ((n >>  2) & 0x3333333333333333)
+      n    = ((n & 0x0f0f0f0f0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f0f0f0f0f)
+      n    = ((n & 0x00ff00ff00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff00ff00ff)
+      n    = ((n & 0x0000ffff0000ffff) << 16) | ((n >> 16) & 0x0000ffff0000ffff)
+      return ((n & 0x00000000ffffffff) << 32) |  (n >> 32) # 0x00000000ffffffff
+    end
+
+    def bitreflect128(n)
+      n    = n.to_i
+      n    = ((n & 0x55555555555555555555555555555555) <<  1) | ((n >>  1) & 0x55555555555555555555555555555555)
+      n    = ((n & 0x33333333333333333333333333333333) <<  2) | ((n >>  2) & 0x33333333333333333333333333333333)
+      n    = ((n & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
+      n    = ((n & 0x00ff00ff00ff00ff00ff00ff00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
+      n    = ((n & 0x0000ffff0000ffff0000ffff0000ffff) << 16) | ((n >> 16) & 0x0000ffff0000ffff0000ffff0000ffff)
+      n    = ((n & 0x00000000ffffffff00000000ffffffff) << 32) | ((n >> 32) & 0x00000000ffffffff00000000ffffffff)
+      return ((n & 0x0000000000000000ffffffffffffffff) << 64) |  (n >> 64) # 0x0000000000000000ffffffffffffffff
+    end
+  end
+
+  class Generator < Struct.new(:bitsize, :bitmask, :polynomial, :initial_state, :table8, :reflect_input, :reflect_output, :xor_output, :name)
+    BasicStruct = superclass
+
+    def initialize(bitsize, polynomial, initial_state = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil)
+      bitsize = bitsize.to_i
+      if bitsize < 1 || bitsize > 64
+        raise ArgumentError, "wrong bitsize (except 1..64, but given #{bitsize})"
+      end
+      bitmask = ~(~0 << bitsize)
+      polynomial = bitmask & polynomial
+      initial_state = bitmask & initial_state
+      xor_output = bitmask & xor_output
+      name = (name.nil? || ((name = String(name)).empty?)) ? nil : name
+      super(bitsize, bitmask, polynomial, initial_state, nil,
+            !!reflect_input, !!reflect_output, xor_output, name)
+    end
+
+    def update_with_reference(seq, state)
+      if reflect_input
+        poly = CRC.bitreflect(polynomial, bitsize)
+        seq.each_byte do |ch|
+          state ^= ch
+          8.times { state = (state[0] == 0) ? (state >> 1) : ((state >> 1) ^ poly) }
+
+          # 8.times { state = (state >> 1) ^ (poly & -state[0]) }
+          # NOTE: ruby だと、分岐したほうが2割くらい高速
+        end
+
+        state
+      else
+        Aux.slide_to_head(bitsize, state, polynomial, bitmask) do |s, poly, csh, head, carries|
+          seq.each_byte do |ch|
+            s ^= ch << csh
+            8.times { s = (s[head] == 0) ? (s << 1) : (((carries & s) << 1) ^ poly) }
+          end
+
+          s
+        end
+      end
+    end
+
+    def update_with_lookup_table(seq, state)
+      t = table8[0]
+
+      if reflect_input
+        String(seq).each_byte do |ch|
+          state = t[state & 0xff ^ ch] ^ (state >> 8)
+        end
+        state
+      else
+        Aux.slide_to_head(bitsize, state, polynomial, bitmask) do |s, poly, csh, head, carries|
+          carries8 = carries >> 7
+          String(seq).each_byte do |ch|
+            s = t[(s >> csh) ^ ch] ^ ((carries8 & s) << 8)
+          end
+          s
+        end
+      end
+    end
+
+    def update_with_slice_by_eight(seq, s)
+      tX = table8
+      t0 = tX[ 0]; t1 = tX[ 1]; t2 = tX[ 2]; t3 = tX[ 3]
+      t4 = tX[ 4]; t5 = tX[ 5]; t6 = tX[ 6]; t7 = tX[ 7]
+      t8 = tX[ 8]; t9 = tX[ 9]; tA = tX[10]; tB = tX[11]
+      tC = tX[12]; tD = tX[13]; tE = tX[14]; tF = tX[15]
+
+      i = 0
+      ii = seq.bytesize
+      iii = ii & ~15
+
+      if reflect_input
+        if bitsize <= 32
+          # speed improvement for 32-bits CRC
+          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)                   ] ^ 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
+          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] ^
+                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
+
+        (iii...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
+          end
+
+          carries8 = carries >> 7
+          (iii...ii).each do |n|
+            s = t0[(s >> csh) ^ seq.getbyte(n)] ^ ((carries8 & s) << 8)
+          end
+          s
+        end
+      end
+    end
+
+    def table8
+      unless t = super
+        if reflect_input
+          set_table8 t = CRC.build_table8!(bitsize, polynomial)
+        else
+          set_table8 t = CRC.build_table8(bitsize, polynomial)
+        end
+      end
+
+      define_singleton_method :table8, self.class.superclass.instance_method(:table8)
+
+      t
+    end
+
+    case ENV["RUBY_CRC_NOFAST"].to_i
+    when 0, 1
+      alias update update_with_slice_by_eight
+    when 2
+      alias update update_with_lookup_table
+    else
+      alias update update_with_reference
+    end
+
+    class BasicStruct
+      alias set_table8 table8=
+      private :set_table8
+
+      undef :bitsize=, :bitmask=, :polynomial=, :initial_state=, :table8=,
+            :reflect_input=, :reflect_output=, :xor_output=, :name=, :[]=
+    end
+  end
+end

data/lib/crc/_modules.rb

@@ -0,0 +1,105 @@
+#!ruby
+
+module CRC
+
+  #
+  # references from:
+  #   * https://en.wikipedia.org/wiki/Cyclic_redundancy_check
+  #   * https://ja.wikipedia.org/wiki/%E5%B7%A1%E5%9B%9E%E5%86%97%E9%95%B7%E6%A4%9C%E6%9F%BB
+  #   * http://reveng.sourceforge.net/crc-catalogue/all.htm
+  #   * http://crcmod.sourceforge.net/crcmod.predefined.html
+  #   * https://users.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf
+  #
+
+  list = [
+    #
+    # module name,        polynomial,     refrect input,
+    #                           bit size,       reflect output,
+    #                              initial state,     xor external,   crc("123456789"), alias names...
+    #
+    [:CRC1,                     0x01,  1,      0,  true,  true, ~0,                nil, "CRC-1"],
+    [:CRC3_ROHC,                0x03,  3,     ~0,  true,  true,  0,               0x06, "CRC-3-ROHC"],
+    [:CRC4_ITU,                 0x03,  4,      0,  true,  true,  0,               0x07, "CRC-4-ITU"],
+    [:CRC5_EPC,                 0x09,  5,   0x09, false, false,  0,               0x00, "CRC-5-EPC"],
+    [:CRC5_ITU,                 0x15,  5,      0,  true,  true,  0,               0x07, "CRC-5-ITU"],
+    [:CRC5_USB,                 0x05,  5,      0,  true,  true, ~0,               0x19, "CRC-5-USB"],
+    [:CRC6_CDMA2000_A,          0x27,  6,     ~0, false, false,  0,               0x0D, "CRC-6-CDMA2000-A"],
+    [:CRC6_CDMA2000_B,          0x07,  6,     ~0, false, false,  0,               0x3B, "CRC-6-CDMA2000-B"],
+    [:CRC6_DARC,                0x19,  6,      0,  true,  true,  0,               0x26, "CRC-6-DARC"],
+    [:CRC6_ITU,                 0x03,  6,      0,  true,  true,  0,               0x06, "CRC-6-ITU"],
+    [:CRC7,                     0x09,  7,      0, false, false,  0,               0x75, "CRC-7"],
+    [:CRC7_MVB,                 0x65,  7,      0,  true,  true, ~0,                nil, "CRC-7-MVB"],
+    [:CRC8,                     0xD5,  8,      0,  true,  true, ~0,                nil, "CRC-8"],
+    [:CRC8_CCITT,               0x07,  8,      0,  true,  true, ~0,                nil, "CRC-8-CCITT"],
+    [:CRC8_DALLAS_MAXIM,        0x31,  8,      0,  true,  true, ~0,                nil, "CRC-8-Dallas/Maxim"],
+    [:CRC8_DARC,                0x39,  8,      0,  true,  true,  0,               0x15, "CRC-8-DARC"],
+    [:CRC8_SAE,                 0x1D,  8,      0,  true,  true, ~0,                nil, "CRC-8-SAE"],
+    [:CRC8_WCDMA,               0x9B,  8,      0,  true,  true,  0,               0x25, "CRC-8-WCDMA"],
+    [:CRC10,                  0x0233, 10,      0, false, false,  0,             0x0199, "CRC-10"],
+    [:CRC10_CDMA2000,         0x03D9, 10,     ~0, false, false,  0,             0x0233, "CRC-10-CDMA2000"],
+    [:CRC11,                  0x0385, 11,   0x1a, false, false,  0,             0x05a3, "CRC-11"],
+    [:CRC12,                  0x080F, 12,      0, false,  true,  0,             0x0daf, "CRC-12"],
+    [:CRC12_CDMA2000,         0x0F13, 12,     ~0, false, false,  0,             0x0d4d, "CRC-12-CDMA2000"],
+    [:CRC13_BBC,              0x1CF5, 13,      0, false, false,  0,             0x04fa, "CRC-13-BBC"],
+    [:CRC14_DARC,             0x0805, 14,      0,  true,  true,  0,             0x082d, "CRC-14-DARC"],
+    [:CRC15_CAN,              0x4599, 15,      0, false, false,  0,             0x059e, "CRC-15-CAN"],
+    [:CRC15_MPT1327,          0x6815, 15,      1, false, false,  1,                nil, "CRC-15-MPT1327"],
+    [:CHAKRAVARTY,            0x2F15, 16,      0,  true,  true, ~0,                nil, "Chakravarty"],
+    [:CRC16_ARINC,            0xA02B, 16,      0,  true,  true, ~0,                nil, "CRC-16-ARINC"],
+    [:CRC16_CCITT,            0x1021, 16,      0,  true,  true, ~0,                nil, "CRC-16-CCITT", "CRC-CCITT"],
+    [:CRC16_CDMA2000,         0xC867, 16,      0,  true,  true, ~0,                nil, "CRC-16-CDMA2000"],
+    [:CRC16_DECT,             0x0589, 16,      0,  true,  true, ~0,                nil, "CRC-16-DECT"],
+    [:CRC16_T10_DIF,          0x8BB7, 16,      0,  true,  true, ~0,                nil, "CRC-16-T10-DIF"],
+    [:CRC16_DNP,              0x3D65, 16,      0,  true,  true, ~0,                nil, "CRC-16-DNP"],
+    [:CRC16_IBM,              0x8005, 16,      0,  true,  true, ~0,                nil, "CRC-16-IBM", "CRC-16", "CRC-16-ANSI"],
+    [:CRC16_LZH,              0x8005, 16,      0,  true,  true,  0,             0xBB3D, "CRC-16-LZH", "CRC-LZH"],
+    [:CRC17_CAN,          0x0001685B, 17,      0,  true,  true, ~0,                nil, "CRC-17-CAN"],
+    [:CRC21_CAN,          0x00102899, 21,      0,  true,  true, ~0,                nil, "CRC-21-CAN"],
+    [:CRC24,              0x005D6DCB, 24,      0,  true,  true, ~0,                nil, "CRC-24"],
+    [:CRC24_RADIX_64,     0x00864CFB, 24,      0,  true,  true, ~0,                nil, "CRC-24-Radix-64"],
+    [:CRC30,              0x2030B9C7, 30,      0,  true,  true, ~0,                nil, "CRC-30"],
+    [:CRC32,              0x04c11db7, 32,      0,  true,  true, ~0,         0xCBF43926, "CRC-32"],
+    [:CRC32C,             0x1edc6f41, 32,      0,  true,  true, ~0,         0xE3069283, "CRC-32C"],
+    [:CRC32K,             0x741B8CD7, 32,      0,  true,  true, ~0,                nil, "CRC-32K"],
+    [:CRC32K2,            0x32583499, 32,      0,  true,  true, ~0,                nil, "CRC-32K2"],
+    [:CRC32Q,             0x814141AB, 32,      0, false, false,  0,         0x3010BF7F, "CRC-32Q"],
+    [:CRC40_GSM,  0x0000000004820009, 40,     ~0, false, false, ~0,       0xD4164FC646, "CRC-40-GSM"],
+    [:CRC64_ECMA, 0x42F0E1EBA9EA3693, 64,      0,  true,  true, ~0, 0x995DC9BBDF1939FA, "CRC-64-ECMA", "CRC-64"],
+    [:CRC64_ISO,  0x000000000000001B, 64,      0,  true,  true, ~0,                nil, "CRC-64-ISO"],
+  ]
+
+  $stderr.puts "#{__FILE__}:#{__LINE__}: SELF CHECK for CRC modules (#{File.basename($".grep(/\/crc\/_(?:byruby|turbo)/)[0]||"")})\n" if SELF_TEST
+  list.each do |name, polynomial, bitsize, initial_state, refin, refout, xor, check, *names|
+    names.map! { |nm| nm.freeze }
+
+    crc = create_module(bitsize, polynomial, initial_state, refin, refout, xor, names[0])
+
+    const_set(name, crc)
+    names.each { |nm| MODULE_TABLE[nm.downcase.gsub(/[\W_]+/, "")] = crc }
+
+    check = Integer(check.to_i) if check
+    crc.const_set :CHECK, check
+
+    generator = crc::GENERATOR
+    define_singleton_method(name.downcase, ->(*args) { generator.crc(*args) })
+    define_singleton_method("#{name.downcase}_digest", ->(*args) { generator.digest(*args) })
+    define_singleton_method("#{name.downcase}_hexdigest", ->(*args) { generator.hexdigest(*args) })
+
+    if SELF_TEST
+      checked = generator.crc("123456789")
+      case
+      when check.nil?
+        $stderr.puts "| %20s(\"123456789\") = %16X (check only)\n" % [names[0], checked]
+      when check != checked
+        $stderr.puts "| %20s(\"123456789\") = %16X (expect to %016X)\n" % [names[0], checked, check]
+      end
+    end
+  end
+  exit if SELF_TEST
+
+  class << self
+    alias crc64 crc64_ecma
+  end
+
+  CRC64 = CRC64_ECMA
+end

data/lib/crc/finder.rb

@@ -0,0 +1,29 @@
+require_relative "../crc"
+
+module CRC
+  def self.find(crc, seq, bitsize, polynomial, initstate = [0, ~0, 1], xor = [0, ~0, 1])
+    bitsize0 = bitsize.to_i
+    if bitsize0 < 1 || bitsize0 > 128
+      raise ArgumentError, "wrong bitsize (expect 1..128, but given #{bitsize})"
+    end
+    bitmask = ~(~0 << bitsize0)
+    crc &= bitmask
+    [polynomial, Utils.bitreflect(polynomial, bitsize0)].each do |poly|
+      poly &= bitmask
+      [false, true].each do |refin|
+        [false, true].each do |refout|
+          Array(xor).each do |xormask|
+            xormask &= bitmask
+            Array(initstate).each do |init|
+              init &= bitmask
+              mod = CRC.create_module(bitsize0, poly, init, refin, refout, xormask)
+              return mod if mod.crc(seq) == crc
+            end
+          end
+        end
+      end
+    end
+
+    nil
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: crc
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- dearblue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-08 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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+description: |
+  This is a general CRC (Cyclic Redundancy Check) generator for ruby.
+  It is written by pure ruby with based on slice-by-eight algorithm (byte-order-free slice-by-16 algorithm).
+  Included built-in CRC modules are CRC-32, CRC-64-ECMA, CRC-64-ISO, CRC-16-CCITT, CRC-16-IBM, CRC-8, CRC-5-USB, CRC-5-EPC and more.
+  And your defined CRC modules to use.
+  If you need more speed, please use crc-turbo.
+email: dearblue@users.osdn.me
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- lib/crc.rb
+- lib/crc/_byruby.rb
+- lib/crc/_modules.rb
+- lib/crc/finder.rb
+files:
+- LICENSE
+- README.md
+- Rakefile
+- benchmark.rb
+- gemstub.rb
+- lib/crc.rb
+- lib/crc/_byruby.rb
+- lib/crc/_modules.rb
+- lib/crc/finder.rb
+homepage: https://osdn.jp/projects/rutsubo/
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset"
+- UTF-8
+- "-m"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.2
+signing_key: 
+specification_version: 4
+summary: general CRC generator
+test_files: []
+has_rdoc: