version bump 1.0.0: rolling checksums

- browser tests work in IE6+
- miscellaneous adjustments to tooling

Author: SheetJSDev

.flowconfig

@@ -10,13 +10,18 @@
 .*/perf/.*
 
 .*/demo/browser.js
+.*/shim.js
 
 [include]
 crc32.flow.js
+.*/bin/.*.njs
 .*/demo/browser.flow.js
 
 [libs]
 bits/10_types.js
 misc/flow.js
+misc/flowdeps.js
 
 [options]
+module.file_ext=.js
+module.file_ext=.njs

Makefile

@@ -2,6 +2,7 @@ LIB=crc32
 REQS=
 ADDONS=
 AUXTARGETS=demo/browser.js
+CMDS=bin/crc32.njs
 HTMLLINT=index.html
 
 ULIB=$(shell echo $(LIB) | tr a-z A-Z)
@@ -37,6 +38,7 @@ test mocha: test.js $(TARGET) baseline ## Run test suite
 ctest: ## Build browser test (into ctest/ subdirectory)
 	cat misc/*.js > ctest/fixtures.js
 	cp -f test.js ctest/test.js
+	cp -f shim.js ctest/shim.js
 	cp -f $(TARGET) ctest/
 
 .PHONY: ctestserv
@@ -56,6 +58,7 @@ clean-baseline: ## Remove test baselines
 .PHONY: lint
 lint: $(TARGET) $(AUXTARGETS) ## Run jshint and jscs checks
 	@jshint --show-non-errors $(TARGET) $(AUXTARGETS)
+	@jshint --show-non-errors $(CMDS)
 	@jshint --show-non-errors package.json
 	@jshint --show-non-errors --extract=always $(HTMLLINT)
 	@jscs $(TARGET) $(AUXTARGETS)

README.md

@@ -1,52 +1,62 @@
 # crc32
 
 Standard CRC-32 algorithm implementation in JS (for the browser and nodejs).
-Emphasis on correctness and performance.
+Emphasis on correctness, performance, and IE6+ support.
 
 ## Installation
 
 With [npm](https://www.npmjs.org/package/crc-32):
 
-    $ npm install crc-32
+```bash
+$ npm install crc-32
+```
 
 In the browser:
 
-    <script src="crc32.js"></script>
+```html
+<script src="crc32.js"></script>
+```
 
-The browser exposes a variable ADLER32
+The browser exposes a variable `CRC32`.
 
 When installed globally, npm installs a script `crc32` that computes the
 checksum for a specified file or standard input.
 
 The script will manipulate `module.exports` if available (e.g. in a CommonJS
 `require` context).  This is not always desirable.  To prevent the behavior,
-define `DO_NOT_EXPORT_CRC`
+define `DO_NOT_EXPORT_CRC`.
 
 ## Usage
 
-In all cases, the relevant function takes a single argument representing data.
+In all cases, the relevant function takes an argument representing data and an
+optional second argument representing the starting "seed" (for rolling CRC).
 
 The return value is a signed 32-bit integer.
 
-- `CRC32.buf(byte array or buffer)` assumes the argument is a set of 8-bit
-  unsigned integers (e.g. nodejs `Buffer` or simple array of ints).
+- `CRC32.buf(byte array or buffer[, seed])` assumes the argument is a sequence
+  of 8-bit unsigned integers (e.g. nodejs `Buffer` or simple array of ints).
 
-- `CRC32.bstr(binary string)` interprets the argument as a binary string where
-  the `i`-th byte is the low byte of the UCS-2 char: `str.charCodeAt(i) & 0xFF`
+- `CRC32.bstr(binary string[, seed])` assumes the argument is a "binary" string
+  where byte `i` is the low byte of the UCS-2 char: `str.charCodeAt(i) & 0xFF`
 
-- `CRC32.str(string)` interprets the argument as a standard JS string
+- `CRC32.str(string[, seed])` assumes the argument is a standard string and
+  calculates the CRC32 of the UTF-8 encoding.
 
 For example:
 
 ```js
-> // var CRC32 = require('crc-32'); // uncomment this line if in node
-> CRC32.str("SheetJS")                          // -1647298270
-> CRC32.bstr("SheetJS")                         // -1647298270
-> CRC32.buf([ 83, 104, 101, 101, 116, 74, 83 ]) // -1647298270
-
-> [CRC32.str("\u2603"),  CRC32.str("\u0003")]   // [ -1743909036,  1259060791 ]
-> [CRC32.bstr("\u2603"), CRC32.bstr("\u0003")]  // [  1259060791,  1259060791 ]
-> [CRC32.buf([0x2603]),  CRC32.buf([0x0003])]   // [  1259060791,  1259060791 ]
+// var CRC32 = require('crc-32');             // uncomment this line if in node
+CRC32.str("SheetJS")                          // -1647298270
+CRC32.bstr("SheetJS")                         // -1647298270
+CRC32.buf([ 83, 104, 101, 101, 116, 74, 83 ]) // -1647298270
+
+crc32 = CRC32.buf([83, 104])                  // -1826163454  "Sh"
+crc32 = CRC32.str("eet", crc32)               //  1191034598  "Sheet"
+CRC32.bstr("JS", crc32)                       // -1647298270  "SheetJS"
+
+[CRC32.str("\u2603"),  CRC32.str("\u0003")]   // [ -1743909036,  1259060791 ]
+[CRC32.bstr("\u2603"), CRC32.bstr("\u0003")]  // [  1259060791,  1259060791 ]
+[CRC32.buf([0x2603]),  CRC32.buf([0x0003])]   // [  1259060791,  1259060791 ]
 ```
 
 ## Testing
@@ -73,15 +83,15 @@ To generate the bits file, use the `crc32` function from python zlib:
 
 The included `crc32.njs` script can process files or stdin:
 
-```
+```bash
 $ echo "this is a test" > t.txt
 $ bin/crc32.njs t.txt
 1912935186
 ```
 
 For comparison, the included `crc32.py` script uses python zlib:
 
-```
+```bash
 $ bin/crc32.py t.txt
 1912935186
 ```

bin/crc32.njs

@@ -2,36 +2,77 @@
 /* crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */
 /* vim: set ts=2 ft=javascript: */
 
-var X;
+var X/*:CRC32Module*/;
 try { X = require('../'); } catch(e) { X = require('crc-32'); }
+
+function help()/*:number*/ {
+[
+"usage: crc32 [options] [filename]",
+"",
+"Options:",
+"    -h, --help           output usage information",
+"    -V, --version        output the version number",
+"    -S, --seed=<n>       use integer seed as starting value (rolling CRC)",
+"    -H, --hex-seed=<h>   use hex seed as starting value (rolling CRC)",
+"    -d, --signed         print result with format `%d` (default)",
+"    -u, --unsigned       print result with format `%u`",
+"    -x, --hex            print result with format `%0.8x`",
+"    -X, --HEX            print result with format `%0.8X`",
+"    -F, --format=<s>     use specified printf format",
+"",
+"Set filename = '-' or pipe data into crc32 to read from stdin",
+"Default output mode is signed (-d)",
+""
+].forEach(function(l) { console.log(l); });
+	return 0;
+}
+
+function version()/*:number*/ { console.log(X.version); return 0; }
+
 var fs = require('fs');
 require('exit-on-epipe');
 
-var args = process.argv.slice(2);
+function die(msg/*:string*/, ec/*:?number*/)/*:void*/ { console.error(msg); process.exit(ec || 0); }
 
-var filename;
-if(args[0]) filename = args[0];
+var args/*:Array<string>*/ = process.argv.slice(2);
+var filename/*:string*/ = "";
+var fmt/*:string*/ = "";
+var seed = 0, r = 10;
 
-if(!process.stdin.isTTY) filename = filename || "-";
+for(var i = 0; i < args.length; ++i) {
+	var arg = args[i];
+	if(arg.charCodeAt(0) != 45) { if(filename === "") filename = arg; continue; }
+	var m = arg.indexOf("=") == -1 ? arg : arg.substr(0, arg.indexOf("="));
+	switch(m) {
+		case "-": filename = "-"; break;
 
-if(!filename) {
-	console.error("crc32: must specify a filename ('-' for stdin)");
-	process.exit(1);
-}
+		case "--help":     case "-h": process.exit(help()); break;
+		case "--version":  case "-V": process.exit(version()); break;
 
-if(filename === "-h" || filename === "--help") {
-	console.log("usage: " + process.argv[0] + " [filename]");
-	process.exit(0);
-}
+		case "--signed":   case "-d": fmt = "%d"; break;
+		case "--unsigned": case "-u": fmt = "%u"; break;
+		case "--hex":      case "-x": fmt = "%0.8x"; break;
+		case "--HEX":      case "-X": fmt = "%0.8X"; break;
+		case "--format":   case "-F":
+			fmt = ((m!=arg) ? arg.substr(m.length+1) : args[++i])||""; break;
+
+		case "--hex-seed": case "-H": r = 16;
+		/* falls through */
+		case "--seed":     case "-S":
+			seed=parseInt((m!=arg) ? arg.substr(m.length+1) : args[++i], r)||0; break;
 
-if(filename !== "-" && !fs.existsSync(filename)) {
-	console.error("crc32: " + filename + ": No such file or directory");
-	process.exit(2);
+		default: die("crc32: unrecognized option `" + arg + "'", 22);
+	}
 }
 
-if(filename === "-") process.stdin.pipe(require('concat-stream')(process_data));
-else process_data(fs.readFileSync(filename));
+if(!process.stdin.isTTY) filename = filename || "-";
+if(filename.length===0) die("crc32: must specify a filename ('-' for stdin)",1);
 
-function process_data(data) {
-	console.log(X.buf(data));
+function process_data(data/*:Buffer*/) {
+	var out/*:CRC32Type*/ = X.buf(data, seed);
+	return console.log(fmt === "" ? out : require("printj").sprintf(fmt, out));
 }
+
+if(filename === "-") process.stdin.pipe(require('concat-stream')(process_data));
+else if(fs.existsSync(filename)) process_data(fs.readFileSync(filename));
+else die("crc32: " + filename + ": No such file or directory", 2);

bits/01_version.js

@@ -1 +1 @@
-CRC32.version = '0.4.1';
+CRC32.version = '1.0.0';

bits/40_crc.js

@@ -1,9 +1,9 @@
 /*# charCodeAt is the best approach for binary strings */
 /*global Buffer */
 var use_buffer = typeof Buffer !== 'undefined';
-function crc32_bstr(bstr/*:string*/)/*:CRC32Type*/ {
-	if(bstr.length > 32768) if(use_buffer) return crc32_buf_8(new Buffer(bstr));
-	var C = -1, L = bstr.length - 1;
+function crc32_bstr(bstr/*:string*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	if(bstr.length > 32768) if(use_buffer) return crc32_buf_8(new Buffer(bstr), seed);
+	var C = seed/*:: ? 0 : 0 */ ^ -1, L = bstr.length - 1;
 	for(var i = 0; i < L;) {
 		C = (C>>>8) ^ T[(C^bstr.charCodeAt(i++))&0xFF];
 		C = (C>>>8) ^ T[(C^bstr.charCodeAt(i++))&0xFF];
@@ -12,9 +12,9 @@ function crc32_bstr(bstr/*:string*/)/*:CRC32Type*/ {
 	return C ^ -1;
 }
 
-function crc32_buf(buf/*:ABuf*/)/*:CRC32Type*/ {
-	if(buf.length > 10000) return crc32_buf_8(buf);
-	var C = -1, L = buf.length - 3;
+function crc32_buf(buf/*:ABuf*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	if(buf.length > 10000) return crc32_buf_8(buf, seed);
+	var C = seed/*:: ? 0 : 0 */ ^ -1, L = buf.length - 3;
 	for(var i = 0; i < L;) {
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
@@ -25,8 +25,8 @@ function crc32_buf(buf/*:ABuf*/)/*:CRC32Type*/ {
 	return C ^ -1;
 }
 
-function crc32_buf_8(buf/*:ABuf*/)/*:CRC32Type*/ {
-	var C = -1, L = buf.length - 7;
+function crc32_buf_8(buf/*:ABuf*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	var C = seed/*:: ? 0 : 0 */ ^ -1, L = buf.length - 7;
 	for(var i = 0; i < L;) {
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
@@ -42,8 +42,8 @@ function crc32_buf_8(buf/*:ABuf*/)/*:CRC32Type*/ {
 }
 
 /*# much much faster to intertwine utf8 and C */
-function crc32_str(str/*:string*/)/*:CRC32Type*/ {
-	var C = -1;
+function crc32_str(str/*:string*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	var C = seed/*:: ? 0 : 0 */ ^ -1;
 	for(var i = 0, L=str.length, c, d; i < L;) {
 		c = str.charCodeAt(i++);
 		if(c < 0x80) {

crc32.flow.js

@@ -23,7 +23,7 @@ var CRC32;
 	}
 	/*jshint ignore:end */
 }(function(CRC32) {
-CRC32.version = '0.4.1';
+CRC32.version = '1.0.0';
 /*::
 type CRC32Type = number;
 type ABuf = Array<number> | Buffer;
@@ -54,9 +54,9 @@ var T = signed_crc_table();
 /*# charCodeAt is the best approach for binary strings */
 /*global Buffer */
 var use_buffer = typeof Buffer !== 'undefined';
-function crc32_bstr(bstr/*:string*/)/*:CRC32Type*/ {
-	if(bstr.length > 32768) if(use_buffer) return crc32_buf_8(new Buffer(bstr));
-	var C = -1, L = bstr.length - 1;
+function crc32_bstr(bstr/*:string*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	if(bstr.length > 32768) if(use_buffer) return crc32_buf_8(new Buffer(bstr), seed);
+	var C = seed/*:: ? 0 : 0 */ ^ -1, L = bstr.length - 1;
 	for(var i = 0; i < L;) {
 		C = (C>>>8) ^ T[(C^bstr.charCodeAt(i++))&0xFF];
 		C = (C>>>8) ^ T[(C^bstr.charCodeAt(i++))&0xFF];
@@ -65,9 +65,9 @@ function crc32_bstr(bstr/*:string*/)/*:CRC32Type*/ {
 	return C ^ -1;
 }
 
-function crc32_buf(buf/*:ABuf*/)/*:CRC32Type*/ {
-	if(buf.length > 10000) return crc32_buf_8(buf);
-	var C = -1, L = buf.length - 3;
+function crc32_buf(buf/*:ABuf*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	if(buf.length > 10000) return crc32_buf_8(buf, seed);
+	var C = seed/*:: ? 0 : 0 */ ^ -1, L = buf.length - 3;
 	for(var i = 0; i < L;) {
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
@@ -78,8 +78,8 @@ function crc32_buf(buf/*:ABuf*/)/*:CRC32Type*/ {
 	return C ^ -1;
 }
 
-function crc32_buf_8(buf/*:ABuf*/)/*:CRC32Type*/ {
-	var C = -1, L = buf.length - 7;
+function crc32_buf_8(buf/*:ABuf*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	var C = seed/*:: ? 0 : 0 */ ^ -1, L = buf.length - 7;
 	for(var i = 0; i < L;) {
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
 		C = (C>>>8) ^ T[(C^buf[i++])&0xFF];
@@ -95,8 +95,8 @@ function crc32_buf_8(buf/*:ABuf*/)/*:CRC32Type*/ {
 }
 
 /*# much much faster to intertwine utf8 and C */
-function crc32_str(str/*:string*/)/*:CRC32Type*/ {
-	var C = -1;
+function crc32_str(str/*:string*/, seed/*:?CRC32Type*/)/*:CRC32Type*/ {
+	var C = seed/*:: ? 0 : 0 */ ^ -1;
 	for(var i = 0, L=str.length, c, d; i < L;) {
 		c = str.charCodeAt(i++);
 		if(c < 0x80) {