crc 0.4.0.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69461cc84e80b500fcae459c0b4ce19d99bdb92f
-  data.tar.gz: 13212d4202a2f3ac678c6e6345226fc3220e391b
+  metadata.gz: e8e6fc81bbcef03f0e899ac1938b7535ddaa344a
+  data.tar.gz: 254fc51f632a763e49fd0d9483cb28c8265fbda3
 SHA512:
-  metadata.gz: 542043f97a8cb06d3afa1487fc7169ccb1d4db5dd6cb0674e76c6548f7fcdac35108a3cbf177f9e19e41286438f20d9c2f7fdd0e646a12a36aac243cbc101567
-  data.tar.gz: fbaf27266779e6da9b536ae65e3e07c8775bfbd9ea91ad515e831ec29417a92060b7db293229d963643f4e5ad411916fd91f95bb2fa0fabab3a77c2736018f4b
+  metadata.gz: c2a19eac87f476a4a3fec5c1646d465d689a36ce5e04782a978d4acd8823823c130e4c26deaa19ac1d78881151c28641f2456f4a41b6c48d8ba21290af0a79e5
+  data.tar.gz: ea0a58a84d5dce2c66e2f3ca9a3f2374d249034c64b54f138aa1bc451ece1a1e31b3d7c69f62f1b5f22227bea2801b27b1a32ed51e7af62193892626eed45097

data/HISTORY.ja.md

@@ -2,6 +2,12 @@ This document is written in Japanese.
 
 # crc for ruby の更新履歴
 
+## crc-0.4.1 (平成29年4月1日 土曜日)
+
+  * rbcrc -lvv の表示に、ビット反転多項式、相反多項式、初期内部状態、ビット反転魔法数を追加
+  * ``dump_to_c`` に slicing-by-2 から slicing-by-999 までの出力機能を追加
+
+
 ## crc-0.4.0.1 (平成29年3月28日 火曜日)
 
   * acrc、shift 系メソッドのバグ修正

data/README.md

@@ -20,7 +20,7 @@ If you need more speed, please use with [crc-turbo](https://rubygems/gems/crc-tu
   * author: dearblue (mailto:dearblue@users.noreply.github.com)
   * report issue to: <https://github.com/dearblue/ruby-crc/issues>
   * how to install: ``gem install crc``
-  * version: 0.4.0.1
+  * version: 0.4.1
   * production quality: TECHNICAL PREVIEW
   * licensing:
       * ***BSD-2-Clause : MAIN LICENSE***
@@ -42,8 +42,8 @@ This examples are used CRC-32 module. Please see CRC for more details.
   * ``CRC.crc32(seq, init = CRC::CRC32.initial_crc) => crc-32 integer`` (likely as ``Zlib.crc32``)
   * ``CRC.crc32.crc(seq, init = CRC::CRC32.initial_crc) => crc-32 integer`` (likely as ``Zlib.crc32``)
   * ``CRC.crc32.digest(seq, init = CRC::CRC32.initial_crc) => 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[seq, init = 0, current_length = 0] -> crc-32 calcurator``
+  * ``CRC.crc32.hexdigest(seq, init = CRC::CRC32.initial_crc) -> crc-32 hex-digest`` (likely as ``Digest::XXXX.hexdigest``)
+  * ``CRC.crc32[seq, init = CRC::CRC32.initial_crc, current_length = 0] -> crc-32 calcurator``
 
 ### Calcurate by streaming
 
@@ -170,7 +170,7 @@ About LICENSE for generated source code:
 
 Algorithms (C file type only):
   bit-by-bit, bit-by-bit-fast, halfbyte-table, standard-table,
-  slicing-by-4, slicing-by-8, slicing-by-16
+  slicing-by-4, slicing-by-8, slicing-by-16, slicing-by-{2..999}
 
 Support export file types:
   * .c for C (support C89, but required ``stdint.h'')
@@ -207,13 +207,14 @@ And, this command has feature too that is print for each CRC specifications as Y
 $ rbcrc -lvv
 ...snip...
 "CRC-32":
-  bitsize:        32
-  polynomial:     0x04C11DB7
-  reflect input:  true
-  reflect output: true
-  initial crc:    0x00000000
-  xor output:     0xFFFFFFFF
-  magic number:   0x2144DF1C
+  bitsize:              32
+  polynomial:           0x04C11DB7  # 0xEDB88320 (bit reflected)
+  reversed reciprocal:  0x82608EDB  # 0xDB710641 (bit reflected)
+  reflect input:        true
+  reflect output:       true
+  initial crc:          0x00000000  # 0xFFFFFFFF (initial state)
+  xor output:           0xFFFFFFFF
+  magic number:         0x2144DF1C  # 0xDEBB20E3 (internal state)
   another names:
   - "CRC-32-ADCCP"
   - "CRC-32-PKZIP"

data/bin/rbcrc

@@ -68,16 +68,18 @@ OptionParser.new("usage: #{File.basename $0} [options] output-filename...", 12,
       "bitbybitfast" => CRC::ALGORITHM_BITBYBIT_FAST,
       "halfbytetable" => CRC::ALGORITHM_HALFBYTE_TABLE,
       "standardtable" => CRC::ALGORITHM_STANDARD_TABLE,
-      "sliceby4" => CRC::ALGORITHM_SLICING_BY_4,
-      "slicingby4" => CRC::ALGORITHM_SLICING_BY_4,
-      "sliceby8" => CRC::ALGORITHM_SLICING_BY_8,
-      "slicingby8" => CRC::ALGORITHM_SLICING_BY_8,
-      "sliceby16" => CRC::ALGORITHM_SLICING_BY_16,
-      "slicingby16" => CRC::ALGORITHM_SLICING_BY_16,
     }[xx]
     unless algorithm
-      raise OptionParser::InvalidOption,
-            "wrong algorithm name - ``#{x}'' (except bit-by-bit, bit-by-bit-fast, halfbyte-table, standard-table, slicing-by-4, slicing-by-8, slicing-by-16)"
+      unless xx =~ /\A(?:slic(?:e|ing)by|sb)(\d+)\z/
+        raise OptionParser::InvalidOption,
+              "wrong algorithm name - ``#{x}'' (except bit-by-bit, bit-by-bit-fast, halfbyte-table, standard-table or slicing-by-{2..999})"
+      end
+
+      algorithm = $1.to_i
+      unless algorithm >= 2 && algorithm <= 999
+        raise OptionParser::InvalidOption,
+              "wrong number for slicing-by-N (given #$1, expect 2..999)"
+      end
     end
   }
 
@@ -96,7 +98,7 @@ About LICENSE for generated source code:
 
 Algorithms (C file type only):
   bit-by-bit, bit-by-bit-fast, halfbyte-table, standard-table,
-  slicing-by-4, slicing-by-8, slicing-by-16
+  slicing-by-4, slicing-by-8, slicing-by-16, slicing-by-{2..999}
 
 Support export file types:
   * .c for C (support C89, but required ``stdint.h'')
@@ -106,22 +108,22 @@ Support export file types:
                  (executable for mruby and limitation bitsize by fixnum)
 
 examples:
-  * create crc-32 generator to c source (and header file)
+  * create crc-32 calcurator to c source (and header file)
     $ rbcrc crc32.c
 
-  * create crc-32c generator to ruby source
+  * create crc-32c calcurator to ruby source
     $ rbcrc crc32c.rb
 
-  * create crc-30-cdma generator to javascript source
+  * create crc-30-cdma calcurator to javascript source
     $ rbcrc crc30cdma.js
 
-  * create crc-32 generator to ``crc.c'', ``crc.rb'' and ``crc.js''
+  * create crc-32 calcurator to ``crc.c'', ``crc.rb'' and ``crc.js''
     $ rbcrc -mcrc32 crc.c crc.rb crc.js
 
-  * create customized crc generator (as mycrc function) to ``mycrc.c''
+  * create customized crc calcurator (as mycrc function) to ``mycrc.c''
     $ rbcrc -s15 -p0x6789 -io -x~0 mycrc.c
 
-  * create customized crc generator (as MyCRC class) to ``mycrc_1.rb''
+  * create customized crc calcurator (as MyCRC class) to ``mycrc_1.rb''
     $ rbcrc -s39 -p0x987654321 -IO -x1 -nMyCRC mycrc_1.rb
   EOS
 
@@ -195,26 +197,35 @@ begin
         bytesize = (e[0] + 7) / 8
         bitmask = ~(~0 << e[0])
         hex = ->(n) { "0x%0*X" % [bytesize * 2, bitmask & n] }
-        names = e[8 .. -1]
-        if names.empty?
-          names = nil
-        else
-          names = <<-YAML_FORMAT.chomp!
+        revrec = (e[1] >> 1) | (1 << (e[0] - 1)) # reversed reciprocal
+        if e[2]
+          refpoly = "  \# #{hex[CRC.bitreflect(e[1], e[0])]} (bit reflected)"
+          recpoly = "  \# #{hex[CRC.bitreflect(revrec, e[0])]} (bit reflected)"
+        end
+        unless e[5] == 0
+          internalstate = "  \# #{hex[e[4] ^ e[5]]} (initial state)"
+          internalmagic = "  \# #{hex[CRC[e[7]].magicnumber ^ e[5]]} (internal state)"
+        end
+        spec = <<-YAML
+"#{e[7]}":
+  bitsize:              #{e[0]}
+  polynomial:           #{hex[e[1]]}#{refpoly}
+  reversed reciprocal:  #{hex[revrec]}#{recpoly}
+  reflect input:        #{e[2].inspect}
+  reflect output:       #{e[3].inspect}
+  initial crc:          #{hex[e[4]]}#{internalstate}
+  xor output:           #{hex[e[5]]}
+  magic number:         #{hex[CRC[e[7]].magicnumber]}#{internalmagic}
+        YAML
 
+        unless (names = e[8 .. -1]).empty?
+          spec << <<-YAML
   another names:
   - "#{names.join(%("\n  - "))}"
-          YAML_FORMAT
+          YAML
         end
-        puts <<-YAML_FORMAT
-"#{e[7]}":
-  bitsize:        #{e[0]}
-  polynomial:     #{hex[e[1]]}
-  reflect input:  #{e[2].inspect}
-  reflect output: #{e[3].inspect}
-  initial crc:    #{hex[e[4]]}
-  xor output:     #{hex[e[5]]}
-  magic number:   #{hex[CRC[e[7]].magicnumber]}#{names}
-        YAML_FORMAT
+
+        puts spec
       end
     end
   else
@@ -243,8 +254,9 @@ begin
                            normalin.nil? ? wcrc.reflect_input? : !normalin,
                            normalout.nil? ? wcrc.reflect_output? : !normalout,
                            wxor)
-            wcrcname = crcname || basename
           end
+
+          wcrcname = crcname || basename
         end
 
         case type

data/bin/rbcrc.orig

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+
+require "crc/codegen"
+require "optparse"
+
+def parse_number(t)
+  case t.strip
+  when /^~(\w+)$/
+    ~Integer($1)
+  else
+    Integer(t)
+  end
+end
+
+mode = nil
+crc = nil
+crcname = nil
+bitsize = nil
+polynomial = nil
+initcrc = nil
+initstate = nil
+xormask = nil
+normalin = nil
+normalout = nil
+algorithm = CRC::ALGORITHM_SLICING_BY_16
+forceoverwrite = false
+verbose = 1
+
+OptionParser.new("usage: #{File.basename $0} [options] output-filename...", 12, " ").instance_eval do
+  on("-m crcname", "choose included crc name in library (``-l'' to print list)") do |x|
+    begin
+      crc = CRC.lookup(x)
+    rescue
+      raise OptionParser::InvalidOption,
+            "not matched crc name - #{x.strip} (if check name, use ``-l'' switch)"
+    end
+  end
+  on("-n crcname", "declare function name or class name [DEFAULT is filename]") { |x| crcname = x.strip }
+  on("-s bitsize", "declare crc bit size [REQUIRED for customized crc]") do |x|
+    bitsize = x.to_i
+    unless bitsize >= 1 && bitsize <= 64
+      raise OptionParser::InvalidOption,
+            "wrong bitsize (given #{bitsize}, expect 1..64)"
+    end
+  end
+  on("-p polynom", "declare crc polynomial [REQUIRED for customized crc]") do |x|
+    polynomial = Integer(x)
+  end
+  on("-c initcrc", "declare initial crc (not internal state) [DEFAULT: 0]") do |x|
+    initcrc = parse_number(x)
+    initstate = nil
+  end
+  on("-S initstate", " declare initial state (internal state) [DEFAULT: unset]") do |x|
+    initcrc = nil
+    initstate = parse_number(x)
+  end
+  on("-x xormask", "declare xor bit mask for when output [DEFAULT: ~0]") do |x|
+    xormask = parse_number(x)
+  end
+  on("-i", "reflect input [DEFAULT]") { |x| normalin = false }
+  on("-I", "normal input (not reflect)") { |x| normalin = true }
+  on("-o", "reflect output [DEFAULT]") { |x| normalout = false }
+  on("-O", "normal output (not reflect)") { |x| normalout = true }
+  on("-a algorithm", " switch algorithm (see below) (C file type only)") { |x|
+    xx = x.downcase.gsub(/[^0-9a-z]+/m, "")
+    algorithm = {
+      "bitbybit" => CRC::ALGORITHM_BITBYBIT,
+      "bitbybitfast" => CRC::ALGORITHM_BITBYBIT_FAST,
+      "halfbytetable" => CRC::ALGORITHM_HALFBYTE_TABLE,
+      "standardtable" => CRC::ALGORITHM_STANDARD_TABLE,
+      "sliceby4" => CRC::ALGORITHM_SLICING_BY_4,
+      "slicingby4" => CRC::ALGORITHM_SLICING_BY_4,
+      "sliceby8" => CRC::ALGORITHM_SLICING_BY_8,
+      "slicingby8" => CRC::ALGORITHM_SLICING_BY_8,
+      "sliceby16" => CRC::ALGORITHM_SLICING_BY_16,
+      "slicingby16" => CRC::ALGORITHM_SLICING_BY_16,
+    }[xx]
+    unless algorithm
+      raise OptionParser::InvalidOption,
+            "wrong algorithm name - ``#{x}'' (except bit-by-bit, bit-by-bit-fast, halfbyte-table, standard-table, slicing-by-4, slicing-by-8, slicing-by-16)"
+    end
+  }
+
+  separator ""
+
+  on("-l", "print crc names") { mode = :list }
+  on("-f", "force overwrite") { forceoverwrite = true }
+  on("-v", "increment verbosery level") { verbose += 1 }
+  on("-q", "quiet mode (reset verbosery level to zero)") { verbose = 0 }
+
+  separator <<-EOS
+
+About LICENSE for generated source code:
+  Generated code is under Creative Commons License Zero (CC0 / Public Domain).
+  See https://creativecommons.org/publicdomain/zero/1.0/
+
+Algorithms (C file type only):
+  bit-by-bit, bit-by-bit-fast, halfbyte-table, standard-table,
+  slicing-by-4, slicing-by-8, slicing-by-16
+
+Support export file types:
+  * .c for C (support C89, but required ``stdint.h'')
+  * .js for javascript (required ECMAScript 6th edition)
+  * .rb for ruby (for ruby-2.1+, jruby, and rubinius)
+                 (executable for ruby-1.8, ruby-1.9 and ruby-2.0)
+                 (executable for mruby and limitation bitsize by fixnum)
+
+examples:
+  * create crc-32 generator to c source (and header file)
+    $ rbcrc crc32.c
+
+  * create crc-32c generator to ruby source
+    $ rbcrc crc32c.rb
+
+  * create crc-30-cdma generator to javascript source
+    $ rbcrc crc30cdma.js
+
+  * create crc-32 generator to ``crc.c'', ``crc.rb'' and ``crc.js''
+    $ rbcrc -mcrc32 crc.c crc.rb crc.js
+
+  * create customized crc generator (as mycrc function) to ``mycrc.c''
+    $ rbcrc -s15 -p0x6789 -io -x~0 mycrc.c
+
+  * create customized crc generator (as MyCRC class) to ``mycrc_1.rb''
+    $ rbcrc -s39 -p0x987654321 -IO -x1 -nMyCRC mycrc_1.rb
+  EOS
+
+  begin
+    parse!
+
+    if bitsize && polynomial.nil?
+      raise OptionParser::InvalidOption,
+            "given ``-s'' switch only (need ``-p'' switch too)"
+    end
+  rescue OptionParser::InvalidOption
+    $stderr.puts <<-ERRORTEXT
+#$0: #$! (#{$!.class})
+\tor enter ``#$0 --help'' to print help.
+    ERRORTEXT
+    exit 1
+  end
+
+  if ARGV.empty? && mode.nil?
+    puts help
+    exit 1
+  end
+end
+
+def write_to_file(forceoverwrite, *filenames)
+  unless forceoverwrite
+    isexist = false
+    filenames.each do |nm|
+      next unless File.exist?(nm)
+      $stderr.puts "#$0: file exist - #{nm} (please use ``-f'' switch, if you want to overwrite)\n"
+      isexist = true
+    end
+
+    return nil if isexist
+  end
+
+  begin
+    cleanup = true
+    files = filenames.map do |nm|
+      File.open(nm, "ab") { } # write test
+      fd = File.open(nm + "~", "wb")
+      fd.define_singleton_method(:path, -> { nm })
+      fd
+    end
+    yield *files
+    cleanup = false
+  ensure
+    if files
+      if cleanup
+        files.each { |fd| fd.close rescue nil; File.unlink fd.path + "~" rescue nil }
+      else
+        files.each { |fd| fd.close; File.rename fd.path + "~", fd.path }
+      end
+    end
+  end
+end
+
+begin
+  case mode
+  when :list
+    case verbose
+    when 0
+      puts CRC::LIST.map {|e| e[7] }.join(", ")
+    when 1
+      puts CRC::LIST.map {|e| e[7 .. -1] }.join(", ")
+    when 2
+      puts CRC::LIST.map {|e| e[7 .. -1].join(", ") }.join("\n")
+    else
+      puts "## This is YAML format\n"
+      CRC::LIST.each do |e|
+        bytesize = (e[0] + 7) / 8
+        bitmask = ~(~0 << e[0])
+        hex = ->(n) { "0x%0*X" % [bytesize * 2, bitmask & n] }
+        revrec = (e[1] >> 1) | (1 << (e[0] - 1)) # reversed reciprocal
+        if e[2]
+          refpoly = "  \# #{hex[CRC.bitreflect(e[1], e[0])]} (bit reflected)"
+          recpoly = "  \# #{hex[CRC.bitreflect(revrec, e[0])]} (bit reflected)"
+        end
+        unless e[5] == 0
+          internalstate = "  \# #{hex[e[4] ^ e[5]]} (initial state)"
+          internalmagic = "  \# #{hex[CRC[e[7]].magicnumber ^ e[5]]} (internal state)"
+        end
+        spec = <<-YAML
+"#{e[7]}":
+  bitsize:              #{e[0]}
+  polynomial:           #{hex[e[1]]}#{refpoly}
+  reversed reciprocal:  #{hex[revrec]}#{recpoly}
+  reflect input:        #{e[2].inspect}
+  reflect output:       #{e[3].inspect}
+  initial crc:          #{hex[e[4]]}#{internalstate}
+  xor output:           #{hex[e[5]]}
+  magic number:         #{hex[CRC[e[7]].magicnumber]}#{internalmagic}
+        YAML
+
+        unless (names = e[8 .. -1]).empty?
+          spec << <<-YAML
+  another names:
+  - "#{names.join(%("\n  - "))}"
+          YAML
+        end
+
+        puts spec
+      end
+    end
+  else
+    ARGV.each do |path|
+      begin
+        basename = File.basename path, ".*"
+        type = File.extname path
+
+        if bitsize
+          wxor = xormask || ~0
+          wcrc = crc || CRC.new(bitsize, polynomial,
+                                initcrc || (initstate ? (initstate ^ wxor) : 0),
+                                !normalin, !normalout, wxor)
+          wcrcname = crcname || basename
+        else
+          begin
+            wcrc = crc || CRC.lookup(basename)
+          rescue
+            raise "not matched crc name from filename - #{basename} (if you want check name, use ``-l'' switch)"
+          end
+
+          if initcrc || initstate || xormask || !normalin.nil? || !normalout.nil?
+            wxor = xormask || wcrc.xor_output
+            wcrc = CRC.new(wcrc.bitsize, wcrc.polynomial,
+                           initcrc || (initstate ? (initstate ^ wxor) : wcrc.initial_crc),
+                           normalin.nil? ? wcrc.reflect_input? : !normalin,
+                           normalout.nil? ? wcrc.reflect_output? : !normalout,
+                           wxor)
+          end
+
+          wcrcname = crcname || basename
+        end
+
+        case type
+        when ".c"
+          write_to_file(forceoverwrite, path.sub(/\.c$/i, ".h"), path) do |cheader, csource|
+            code = wcrc.dump_to_c(wcrcname, File.basename(cheader.path), File.basename(csource.path),
+                                 indent: 4, algorithm: algorithm)
+            cheader << code[:header]
+            csource << code[:source]
+          end
+        when ".js"
+          if wcrc.bitsize > 32
+            raise "bitsize is too big for javascript (given #{wcrc.bitsize}, expect 1..32)"
+          end
+
+          write_to_file(forceoverwrite, path) do |jssource|
+            code = wcrc.dump_to_javascript(wcrcname)
+            jssource << code[:source]
+          end
+        when ".rb"
+          write_to_file(forceoverwrite, path) do |rbsource|
+            code = wcrc.dump_to_ruby(wcrcname)
+            rbsource << code[:source]
+          end
+        else
+          raise "not supported for ``#{type}'' file type"
+        end
+      rescue
+        if $-d
+          $stderr.puts $@.join("\n\t").sub(/$/, ": #$! (#{$!.class})")
+        else
+          $stderr.puts "#$0: #$! - #{path}\n"
+        end
+      end
+    end
+  end
+rescue Errno::EPIPE
+end

data/lib/crc/codegen.rb

@@ -158,12 +158,18 @@ class CRC
       UPDATE_STANDARD_TABLE
     when ALGORITHM_SLICING_BY_4,
          ALGORITHM_SLICING_BY_8,
-         ALGORITHM_SLICING_BY_16
+         ALGORITHM_SLICING_BY_16,
+         2 .. 999
+      if algorithm > 100
+        slicing_format = "table[%3d][p[%3d] %20s]"
+      else
+        slicing_format = "table[%2d][p[%2d] %20s]"
+      end
       slicing = algorithm.times.map { |off|
         ioff = (algorithm - 1) - off
-        "table[%2d][p[%2d] %20s]" % [
-          off, ioff,
-          ioff >= alignedbytes ? nil : "^ #{getleadbyte["s", ioff]}"]
+        slicing_format % [
+          ioff, off,
+          off >= alignedbytes ? nil : "^ #{getleadbyte["s", off]}"]
       }
       if algorithm < alignedbytes
         slicing.insert 0, slideslicing["s"]
@@ -318,14 +324,14 @@ extern "C"
 #
 
 # for ruby-1.8
-unless "".respond_to?(:getbyte)
+unless String.method_defined?(:getbyte)
   class String
     alias getbyte []
   end
 end
 
 # for mruby
-unless [].respond_to?(:freeze)
+unless Array.method_defined?(:freeze)
   class Array
     def freeze
       self
@@ -347,27 +353,9 @@ class #{name.join("::")}
   #
   # call-seq:
   #   initialize(prevcrc = nil)
-  #   initialize(seq, prevcrc = nil)
   #
-  def initialize(*args)
-    case args.size
-    when 0
-      seq = nil
-      prevcrc = nil
-    when 1
-      if args[0].kind_of?(String)
-        seq = args[0]
-      else
-        prevcrc = args[0]
-      end
-    when 2
-      (seq, prevcrc) = args
-    else
-      raise ArgumentError, "wrong number of argument (given \#{args.size}, expect 0..2)"
-    end
-
+  def initialize(prevcrc = nil)
     reset(prevcrc)
-    update(seq) if seq
   end
 
   def reset(prevcrc = nil)
@@ -406,7 +394,9 @@ class #{name.join("::")}
 
   class << self
     def [](seq, prevcrc = nil)
-      new(seq, prevcrc)
+      crc = new(prevcrc)
+      crc << seq
+      crc
     end
 
     def setup(crc = INITIAL_CRC)
@@ -848,7 +838,7 @@ end
         algorithm = "halfbyte-table"
       when ALGORITHM_STANDARD_TABLE
         algorithm = "standard-table"
-      when ALGORITHM_SLICING_BY_4, ALGORITHM_SLICING_BY_8, ALGORITHM_SLICING_BY_16
+      when ALGORITHM_SLICING_BY_4, ALGORITHM_SLICING_BY_8, ALGORITHM_SLICING_BY_16, 2..999
         algorithm = "slicing-by-#{algorithm} (with byte-order free), based Intel's slicing-by-8"
       else
         raise ArgumentError, "out of algorithm code (given #{algorithm})"

data/lib/crc/version.rb

@@ -1,5 +1,5 @@
 #!ruby
 
 class CRC
-  VERSION = "0.4.0.1"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crc
 version: !ruby/object:Gem::Version
-  version: 0.4.0.1
+  version: 0.4.1
 platform: ruby
 authors:
 - dearblue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-28 00:00:00.000000000 Z
+date: 2017-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -31,6 +31,7 @@ description: |
 email: dearblue@users.noreply.github.com
 executables:
 - rbcrc
+- rbcrc.orig
 extensions: []
 extra_rdoc_files:
 - HISTORY.ja.md
@@ -57,6 +58,7 @@ files:
 - Rakefile
 - benchmark.rb
 - bin/rbcrc
+- bin/rbcrc.orig
 - gemstub.rb
 - lib/crc.rb
 - lib/crc/_aux.rb