jsLint cleanups

Author: glinscott

bitEncoder.js

@@ -12,10 +12,11 @@ function BitEncoder() {
 	};
 
 	this.updateModel = function(symbol) {
-		if (symbol == 0)
+		if (symbol === 0) {
 			prob += (kBitModelTotal - prob) >>> kNumMoveBits;
-		else
+		} else {
 			prob -= prob >>> kNumMoveBits;
+		}
 	};
 
 	this.encode = function(encoder, symbol) {
@@ -30,44 +31,48 @@ function BitEncoder() {
 
 	this.initializeProbPrices = function() {
 		var kNumBits = kNumBitModelTotalBits - kNumMoveReducingBits;
-		for (var i = kNumBits - 1; i >= 0; i--) {
+		var i, j;
+		for (i = kNumBits - 1; i >= 0; i--) {
 			var start = 1 << (kNumBits - i - 1);
 			var end = 1 << (kNumBits - i);
-			for (var j = start; j < end; j++)
+			for (j = start; j < end; j++) {
 				this.probPrices[j] = (i << kNumBitPriceShiftBits) +
 					(((end - j) << kNumBitPriceShiftBits) >>> (kNumBits - i - 1));
+			}
 		}
 	};
 
 	// TODO: make this statically initialized
-	if (this.probPrices.length == 0)
+	if (this.probPrices.length === 0) {
 		this.initializeProbPrices();
-};
+	}
+}
 
 BitEncoder.prototype.probPrices = [];
 
 function BitTreeEncoder(numBitLevels) {
 	this.models = [];
 
 	this.init = function() {
-		for (var i = 1; i < (1 << numBitLevels); i++) {
+		var i;
+		for (i = 1; i < (1 << numBitLevels); i++) {
 			this.models[i] = new BitEncoder();
 			this.models[i].init();
 		}
 	};
 
 	this.encode = function(rangeEncoder, symbol) {
-		var m = 1;
-		for (var bitIndex = numBitLevels - 1; bitIndex >= 0; bitIndex--) {
+		var m = 1, bitIndex;
+		for (bitIndex = numBitLevels - 1; bitIndex >= 0; bitIndex--) {
 			var bit = (symbol >>> bitIndex) & 1;
 			this.models[m].encode(rangeEncoder, bit);
 			m = (m << 1) | bit;
 		}
 	};
 
 	this.reverseEncode = function(rangeEncoder, symbol) {
-		var m = 1;
-		for (var i = 0; i < numBitLevels; i++) {
+		var m = 1, i;
+		for (i = 0; i < numBitLevels; i++) {
 			var bit = symbol & 1;
 			this.models[m].encode(rangeEncoder, bit);
 			m = (m << 1) | bit;
@@ -76,16 +81,16 @@ function BitTreeEncoder(numBitLevels) {
 	};
 
 	this.getPrice = function(symbol) {
-		var price = 0, m = 1;
-		for (var i = numBitLevels; i > 0; i--) {
+		var price = 0, m = 1, i;
+		for (i = numBitLevels; i > 0; i--) {
 			var bit = symbol & 1;
 			symbol >>>= 1;
 			price += this.models[m].getPrice(bit);
 			m = (m << 1) | bit;
 		}
 		return price;
 	};
-};
+}
 
 exports.BitTreeEncoder = BitTreeEncoder;
 exports.BitEncoder = BitEncoder;

rangeCoder.js

@@ -3,7 +3,7 @@ var kTopValue = 1 << 24, kBotValue = 1 << 16;
 function shiftLeft8(v) {
 	v <<= 8;
 	return v >= 0 ? v : v + 0x100000000;
-};
+}
 
 function Encoder() {
 	var low = 0, range = 0xFFFFFFFF;
@@ -21,29 +21,31 @@ function Encoder() {
 	};
 
 	this.shiftLow = function() {
-		var overflow = false;
-		if (low < 0xFF000000 || (overflow = low > 0xFFFFFFFF)) {
+		var overflow = low > 0xFFFFFFFF;
+		if (low < 0xFF000000 || overflow) {
 			var temp = cache;
 			do {
 				this.bytes[this.bytes.length] = (temp + (overflow ? 1 : 0)) & 0xFF;
 				temp = 0xFF;
-			} while (--cacheSize != 0);
+			} while (--cacheSize !== 0);
 			cache = low >>> 24;
 		}
 		cacheSize++;
 		low = shiftLeft8(low);
-	}
+	};
 
 	this.finish = function() {
-		for (var i = 0; i < 5; i++)
+		var i;
+		for (i = 0; i < 5; i++) {
 			this.shiftLow();
+		}
 	};
 
 	this.encodeBit = function(size, numTotalBits, symbol) {
 		var newBound = (range >>> numTotalBits) * size;
-		if (symbol == 0)
+		if (symbol === 0) {
 			range = newBound;
-		else {
+		} else {
 			low += newBound;
 			range -= newBound;
 		}
@@ -66,15 +68,17 @@ function Encoder() {
 		}
 	};
 */	
-};
+}
 
 function Decoder(bytes) {
 	var code = 0, range = 0xFFFFFFFF;
 	var at = 0;
+	var i;
 	this.bytes = bytes;
 
-	for (var i = 0; i < 5; i++)
+	for (i = 0; i < 5; i++) {
 		code = (code << 8) | this.bytes[at++];
+	}
 
 	this.normalize = function() {
 		while (range < kTopValue) {
@@ -93,7 +97,7 @@ function Decoder(bytes) {
 		range *= size;
 		this.normalize();
 	};
-};
+}
 
 exports.Encoder = Encoder;
 exports.Decoder = Decoder;

test.js

@@ -15,10 +15,11 @@ var createInStream = function(data) {
 };
 
 var testRangeCoder = function() {
+	var i;
 //	var repeats = 100000;
 	var repeats = 3;
 	var encoder = new RangeCoder.Encoder();
-	for (var i = 0; i < repeats; i++) {
+	for (i = 0; i < repeats; i++) {
 		encoder.encode(0,6,20);
 		encoder.encode(0,6,20);
 		encoder.encode(6,2,20);
@@ -31,7 +32,7 @@ var testRangeCoder = function() {
 	var inside = function(l, r, v) {
 		assert.ok(v >= l && v < r, v + ' not in ' + l + ',' + r);
 	};
-	for (var i = 0; i < repeats; i++) {
+	for (i = 0; i < repeats; i++) {
 		inside(0, 6, decoder.getThreshold(20));
 		decoder.decode(0,6,20);
 		inside(0, 6, decoder.getThreshold(20));
@@ -44,14 +45,15 @@ var testRangeCoder = function() {
 	inside(8, 10, decoder.getThreshold(20));
 };
 
-var testBitEncoder = function(testSequence) {
+var testBitEncoder = function() {
 	// Simple test for the bit encoder
 	var testSequence = [5, 1, 9, 8, 10, 15];
+	var i;
 
 	var bitEncoder = new BitEncoder.BitEncoder();
 	var rangeEncoder = new RangeCoder.Encoder();
 	bitEncoder.init();
-	for (var i = 0; i < testSequence.length; i++) {
+	for (i = 0; i < testSequence.length; i++) {
 		bitEncoder.encode(rangeEncoder, testSequence[i]);
 	}
 	rangeEncoder.finish();
@@ -60,10 +62,12 @@ var testBitEncoder = function(testSequence) {
 
 var testBitTreeEncoder = function(testSequence) {
 	// Test the BitTreeEncoder, using LZMA.js decompression for verification
-	rangeEncoder = new RangeCoder.Encoder();
+	var i;
+	
+	var rangeEncoder = new RangeCoder.Encoder();
 	var bitTreeEncoder = new BitEncoder.BitTreeEncoder(8);
 	bitTreeEncoder.init();
-	for (var i = 0; i < testSequence.length; i++) {
+	for (i = 0; i < testSequence.length; i++) {
 		bitTreeEncoder.encode(rangeEncoder, testSequence[i]);
 	}
 	rangeEncoder.finish();
@@ -75,7 +79,7 @@ var testBitTreeEncoder = function(testSequence) {
 	rangeDecoder.init();
 
 	var result = [];
-	for (var i = 0; i < testSequence.length; i++) {
+	for (i = 0; i < testSequence.length; i++) {
 		result[result.length] = bitTreeDecoder.decode(rangeDecoder);
 	}
 	assert.deepEqual(result, testSequence);