crc 0.3 → 0.3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e420d67c8c057164c47f3fd4a1d6096d28f66a2
-  data.tar.gz: 77ec3196b4ba3164e0659fcffa7a9833e162aa0c
+  metadata.gz: 6d8b8a3e68b73d5b4d330c90908ab880e67f72c2
+  data.tar.gz: 2b035adbace1aad20b824c9611a1a9db5e06ed98
 SHA512:
-  metadata.gz: 7b313c40122e1ee2d953e8fe07520f7787bbea4af884de0fcea1b92263b4791ed189b70696b8885d19bbf33fb56fdcf0f12412a44ade7e2a5f6f91e57d946421
-  data.tar.gz: 157a966f25728523a2edb3de9bf293f0af0bbc1e6484a0bc7b5db8548f6a34abdb5c599d532c5e7b5a119bd41174161517b81d0cf75c49cccdf2596619adfdb8
+  metadata.gz: 52f0617c4756a65178e2c66c155a5b5df96c619b67ffe50e823a89b7476c6c1d9f8ae75faf65053e7cd565bc71371f12ddb07952557f20d311ab146a0fa5c876
+  data.tar.gz: 6e8e41eb6ef956c1a2ec26a1c97895aebe3c0d2e3f074bf8a3bfd6a0e0bc1250e26a7cc5e34a3e71ddbe8b2868fa57463414ce2fc315314484026a904f064914

data/HISTORY.ja.md

@@ -2,6 +2,24 @@ This document is written in Japanese.
 
 # crc for ruby の更新履歴
 
+## crc-0.3.1.1 (平成28年11月10日 木曜日)
+
+  * rbcrc において reflect-input/output が既定値となっていなかったため修正
+
+
+## crc-0.3.1 (平成28年11月10日 木曜日)
+
+  * メソッド名 CRC#update\_with\_slice\_by\_eight を CRC#update\_with\_slice\_by\_16 に変更
+  * 非 reflect-input も slicing-by-16 となるように修正
+  * CRC#update\_with\_slice\_by\_16 の 16 ビット以下の crc に対する最適化
+  * crc 計算におけるルックアップテーブルの作成の高速化
+  * 実装が C か ruby かを判別しやすくするための定数 CRC::IMPLEMENT を追加
+  * CRC-64-JONES を追加
+  * 特定の CRC を計算するソースコード出力機能を追加
+      * c、ruby、javascript 向けのソースコードを出力するための機能を追加しました。
+      * 今のところアルゴリズムは c を除き slicing-by-16 に固定となります。
+
+
 ## crc-0.3 (平成28年7月31日 日曜日)
 
 互換性を損なう変更があります。

data/README.md

@@ -3,11 +3,11 @@
 
 This is a general CRC (Cyclic Redundancy Check) generator for ruby.
 
-It is written by pure ruby with based on slice-by-eight algorithm (slice-by-16 algorithm as byte-order free and byte-alignment free).
+It is written by pure ruby with based on slice-by-eight algorithm (slice-by-16 algorithm with byte-order free).
 
 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 many more.
 
-Customization is posible for 1 to 64 bit width, any polynomial primitives, and with/without bit reflection input/output.
+Customization is posible for 1 to 64 bit width, any polynomials, and with/without bit reflection input/output.
 
 This library is slower than ×85+ of zlib/crc32, and slower than ×120+ of extlzma/crc32 on FreeBSD 10.3R amd64.
 
@@ -20,12 +20,14 @@ If you need more speed, please use [crc-turbo](https://rubygems/gems/crc-turbo).
   * author: dearblue (mailto:dearblue@users.osdn.me)
   * report issue to: <https://osdn.jp/projects/rutsubo/ticket/>
   * how to install: ``gem install crc``
-  * version: 0.3
+  * version: 0.3.1.1
   * release quality: technical preview
   * licensing: BSD-2-Clause<br>any parts are under Creative Commons License Zero (CC0 / Public Domain), and zlib-style License.
   * dependency gems: none
   * dependency external C libraries: none
   * bundled external C libraries: none
+  * installed executable file:
+      * rbcrc: CRC calcuration source code generator for c, ruby and javascript
 
 
 ## API Guide
@@ -45,13 +47,13 @@ This examples are used CRC-32 module. Please see CRC for more details.
 
       * ``CRC.crc32[init = 0, current_length = 0] => crc-32 generator``
       * ``CRC.crc32.new(init = 0, current_length = 0) => crc-32 generator``
-      * ``CRC.crc32#update(seq) => self`` (likely as ``Digest::XXXX.update``)
-      * ``CRC.crc32#finish => crc-32 integer`` (likely as ``Digest::XXXX.finish``)
-      * ``CRC.crc32#crc => crc-32 integer`` (same as ``CRC.crc32#finish``)
-      * ``CRC.crc32#digest => crc-32 digest`` (likely as ``Digest::XXXX.digest``)
-      * ``CRC.crc32#hexdigest => crc-32 hex-digest`` (likely as ``Digest::XXXX.hexdigest``)
+      * ``CRC::CRC32#update(seq) => self`` (likely as ``Digest::XXXX.update``)
+      * ``CRC::CRC32#finish => crc-32 integer`` (likely as ``Digest::XXXX.finish``)
+      * ``CRC::CRC32#crc => crc-32 integer`` (same as ``CRC::CRC32#finish``)
+      * ``CRC::CRC32#digest => crc-32 digest`` (likely as ``Digest::XXXX.digest``)
+      * ``CRC::CRC32#hexdigest => crc-32 hex-digest`` (likely as ``Digest::XXXX.hexdigest``)
 
-    Example:
+    Example::
 
     ``` ruby:ruby
     x = CRC.crc32.new     # => #<CRC::CRC32:00000000>
@@ -67,13 +69,13 @@ This examples are used CRC-32 module. Please see CRC for more details.
       * ``CRC.combine(crc1, crc2, len2) => combined crc integer`` (likely as ``Zlib.crc32_comibne``)
       * ``CRC#+(right_crc) => combined crc generator``
 
-    Example-1:
+    Example-1::
 
     ``` ruby:ruby
     CRC.crc32.combine(CRC.crc32("123"), CRC.crc32("456789"), 6) # => 3421780262
     ```
 
-    Example-2:
+    Example-2::
 
     ``` ruby:ruby
     CRC.crc32["123"] + CRC.crc32["456"] + CRC.crc32["789"] # => #<CRC::CRC32:CBF43926>
@@ -92,26 +94,26 @@ This examples are used CRC-32 module. Please see CRC for more details.
 
   * Calcurate arc-crc (***EXPERIMENTAL***)
 
-      * ``CRC.acrc(pre, post = nil, want_crc = 0) => arc-crc byte string``
+      * ``CRC::XXX.acrc(pre, post = nil, want_crc = 0) => arc-crc byte string``
 
     ``` ruby:ruby
     a = "12"
     c = "789"
-    wantcrc = 0xCBF43926
+    wantcrc = CRC.crc32("123456789")
     b = CRC.crc32.acrc(a, c, wantcrc)   # => "3456"
     CRC.crc32[a + b + c]                # => #<CRC::CRC32:CBF43926>
     ```
 
-    See CRC::ModuleClass.acrc for more detail.
+    See CRC::ModuleClass.acrc or below for more detail.
 
 
 ## Built-in CRC modules
 
 ``` shell:shell
-% ruby -rcrc -e 'puts CRC::MODULE_TABLE.values.uniq.map { |m| m.name }.join(", ")'
+$ ruby -rcrc -e 'puts CRC::MODULE_TABLE.values.uniq.map { |m| m.name }.join(", ")'
 ```
 
-CRC-1, CRC-3-ROHC, CRC-4-INTERLAKEN, 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-7-ROHC, CRC-7-UMTS, CRC-8, CRC-8-CCITT, CRC-8-MAXIM, CRC-8-DARC, CRC-8-SAE, CRC-8-WCDMA, CRC-8-CDMA2000, CRC-8-DVB-S2, CRC-8-EBU, CRC-8-I-CODE, CRC-8-ITU, CRC-8-LTE, CRC-8-ROHC, CRC-10, CRC-10-CDMA2000, CRC-11, CRC-11-UMTS, CRC-12-CDMA2000, CRC-12-DECT, CRC-12-UMTS, CRC-13-BBC, CRC-14-DARC, CRC-15, CRC-15-MPT1327, Chakravarty, CRC-16, CRC-16-ARINC, CRC-16-AUG-CCITT, CRC-16-CDMA2000, CRC-16-DECT-R, CRC-16-DECT-X, CRC-16-T10-DIF, CRC-16-DNP, CRC-16-BUYPASS, CRC-16-CCITT-FALSE, CRC-16-DDS-110, CRC-16-EN-13757, CRC-16-GENIBUS, CRC-16-LJ1200, CRC-16-MAXIM, CRC-16-MCRF4XX, CRC-16-RIELLO, CRC-16-TELEDISK, CRC-16-TMS37157, CRC-16-USB, CRC-16-A, CRC-16-KERMIT, CRC-16-MODBUS, CRC-16-X-25, CRC-16-XMODEM, CRC-17-CAN, CRC-21-CAN, CRC-24, CRC-24-Radix-64, CRC-24-OPENPGP, CRC-24-BLE, CRC-24-FLEXRAY-A, CRC-24-FLEXRAY-B, CRC-24-INTERLAKEN, CRC-24-LTE-A, CRC-24-LTE-B, CRC-30, CRC-30-CDMA, CRC-31-PHILIPS, CRC-32, CRC-32-BZIP2, CRC-32C, CRC-32D, CRC-32-MPEG-2, CRC-32-POSIX, CRC-32K, CRC-32K2, CRC-32Q, CRC-32-JAMCRC, CRC-32-XFER, CRC-40-GSM, CRC-64-XZ, CRC-64-ECMA, CRC-64-WE, CRC-64-ISO
+CRC-1, CRC-3-ROHC, CRC-4-INTERLAKEN, 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-ROHC, CRC-7-UMTS, CRC-8-CCITT, CRC-8-MAXIM, CRC-8-DARC, CRC-8-SAE, CRC-8-WCDMA, CRC-8-CDMA2000, CRC-8-DVB-S2, CRC-8-EBU, CRC-8-I-CODE, CRC-8-ITU, CRC-8-LTE, CRC-8-ROHC, CRC-10, CRC-10-CDMA2000, CRC-11, CRC-11-UMTS, CRC-12-CDMA2000, CRC-12-DECT, CRC-12-UMTS, CRC-13-BBC, CRC-14-DARC, CRC-15, CRC-15-MPT1327, CRC-16, CRC-16-AUG-CCITT, CRC-16-CDMA2000, CRC-16-DECT-R, CRC-16-DECT-X, CRC-16-T10-DIF, CRC-16-DNP, CRC-16-BUYPASS, CRC-16-CCITT-FALSE, CRC-16-DDS-110, CRC-16-EN-13757, CRC-16-GENIBUS, CRC-16-LJ1200, CRC-16-MAXIM, CRC-16-MCRF4XX, CRC-16-RIELLO, CRC-16-TELEDISK, CRC-16-TMS37157, CRC-16-USB, CRC-16-A, CRC-16-KERMIT, CRC-16-MODBUS, CRC-16-X-25, CRC-16-XMODEM, CRC-24-Radix-64, CRC-24-OPENPGP, CRC-24-BLE, CRC-24-FLEXRAY-A, CRC-24-FLEXRAY-B, CRC-24-INTERLAKEN, CRC-24-LTE-A, CRC-24-LTE-B, CRC-30-CDMA, CRC-31-PHILIPS, CRC-32, CRC-32-BZIP2, CRC-32C, CRC-32D, CRC-32-MPEG-2, CRC-32-POSIX, CRC-32Q, CRC-32-JAMCRC, CRC-32-XFER, CRC-40-GSM, CRC-64-XZ, CRC-64-JONES, CRC-64-ECMA, CRC-64-WE, CRC-64-ISO
 
 
 ## Environment variables for behavior
@@ -127,6 +129,72 @@ CRC-1, CRC-3-ROHC, CRC-4-INTERLAKEN, CRC-4-ITU, CRC-5-EPC, CRC-5-ITU, CRC-5-USB,
 CRC.combine is ported from Mark Adler's crccomb.c in <https://stackoverflow.com/questions/29915764/generic-crc-8-16-32-64-combine-implementation#29928573>.
 
 
+## Source code generator for the specific CRC calcurator (from crc-0.3.1)
+
+Add source code generator for the specific CRC calcurator to c, ruby, and javascript.
+
+Algorithm is slicing-by-16 only for ruby and javascript.
+
+For C, be able choose into bit-by-bit, bit-by-bit-fast, halfbyte-table,
+standard-table, slicing-by-4, slicing-by-8, and slicing-by-16.
+
+``` shell:shell
+$ rbcrc --help
+usage: rbcrc [options] output-filename...
+ -M crcname   choose included crc name in library (``-l'' to print list)
+ -N crcname   declare function name or class name [DEFAULT is filename]
+ -s bitsize   declare crc bit size [REQUIRED for customized crc]
+ -p polynom   declare crc polynomial [REQUIRED for customized crc]
+ -c initcrc   declare initial crc (not internal state) [DEFAULT: 0]
+ -S initstate  declare initial state (internal state) [DEFAULT: unset]
+ -x xormask   declare xor bit mask for when output [DEFAULT: ~0]
+ -i           reflect input [DEFAULT]
+ -I           normal input (not reflect)
+ -o           reflect output [DEFAULT]
+ -O           normal output (not reflect)
+ -a algorithm  switch algorithm (see below) (C file type only)
+
+ -l           print crc names
+ -f           force overwrite
+ -v           increment verbosery level
+ -q           quiet mode (reset verbosery level to zero)
+
+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 -r0 -x~0 mycrc.c
+
+  * create customized crc generator (as MyCRC class) to ``mycrc_1.rb''
+    $ rbcrc -s39 -p0x987654321 -IO -r0 -x1 -NMyCRC mycrc_1.rb
+```
+
+
 ## arc-crc (***EXPERIMENTAL***)
 
 (Written in japanese from here)

data/bin/rbcrc

@@ -0,0 +1,282 @@
+#!/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 -r0 -x~0 mycrc.c
+
+  * create customized crc generator (as MyCRC class) to ``mycrc_1.rb''
+    $ rbcrc -s39 -p0x987654321 -IO -r0 -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, 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] }
+        names = e[8 .. -1]
+        if names.empty?
+          names = nil
+        else
+          names = <<-YAML_FORMAT.chomp!
+
+  another names:
+  - "#{names.join(%("\n  - "))}"
+          YAML_FORMAT
+        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]]}#{names}
+        YAML_FORMAT
+      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)
+            wcrcname = crcname || basename
+          end
+        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