gofmt-ify compress

R=rsc
http://go/go-review/1016045

src/pkg/compress/flate/huffman_bit_writer.go

@@ -31,10 +31,10 @@ const (
 
 // The number of extra bits needed by length code X - LENGTH_CODES_START.
 var lengthExtraBits = []int8{
-	/* 257 */0, 0, 0,
-	/* 260 */0, 0, 0, 0, 0, 1, 1, 1, 1, 2,
-	/* 270 */2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
-	/* 280 */4, 5, 5, 5, 5, 0,
+	/* 257 */ 0, 0, 0,
+	/* 260 */ 0, 0, 0, 0, 0, 1, 1, 1, 1, 2,
+	/* 270 */ 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
+	/* 280 */ 4, 5, 5, 5, 5, 0,
 }
 
 // The length indicated by length code X - LENGTH_CODES_START.

src/pkg/compress/flate/huffman_code.go

@@ -10,57 +10,57 @@ import (
 )
 
 type huffmanEncoder struct {
-	codeBits []uint8;
-	code []uint16;
+	codeBits	[]uint8;
+	code		[]uint16;
 }
 
 type literalNode struct {
-	literal uint16;
-	freq int32;
+	literal	uint16;
+	freq	int32;
 }
 
 type chain struct {
 	// The sum of the leaves in this tree
-	freq int32;
+	freq	int32;
 
 	// The number of literals to the left of this item at this level
-	leafCount int32;
+	leafCount	int32;
 
 	// The right child of this chain in the previous level.
-	up *chain;
+	up	*chain;
 }
 
 type levelInfo struct {
 	// Our level.  for better printing
-	level int32;
+	level	int32;
 
 	// The most recent chain generated for this level
-	lastChain *chain;
+	lastChain	*chain;
 
 	// The frequency of the next character to add to this level
-	nextCharFreq int32;
+	nextCharFreq	int32;
 
 	// The frequency of the next pair (from level below) to add to this level.
 	// Only valid if the "needed" value of the next lower level is 0.
-	nextPairFreq int32;
+	nextPairFreq	int32;
 
 	// The number of chains remaining to generate for this level before moving
 	// up to the next level
-	needed int32;
+	needed	int32;
 
 	// The levelInfo for level+1
-	up *levelInfo;
+	up	*levelInfo;
 
 	// The levelInfo for level-1
-	down *levelInfo;
+	down	*levelInfo;
 }
 
 func maxNode() literalNode {
-	return literalNode{ math.MaxUint16, math.MaxInt32 };
+	return literalNode{math.MaxUint16, math.MaxInt32};
 }
 
 func newHuffmanEncoder(size int) *huffmanEncoder {
-	return &huffmanEncoder { make([]uint8, size), make([]uint16, size) };
+	return &huffmanEncoder{make([]uint8, size), make([]uint16, size)};
 }
 
 // Generates a HuffmanCode corresponding to the fixed literal table
@@ -73,18 +73,25 @@ func generateFixedLiteralEncoding() *huffmanEncoder {
 		var bits uint16;
 		var size uint8;
 		switch {
-			case ch < 144:
-				// size 8, 000110000  .. 10111111
-				bits = ch + 48; size = 8; break;
-			case ch < 256:
-				// size 9, 110010000 .. 111111111
-				bits = ch + 400 - 144; size = 9; break;
-			case ch < 280:
-				// size 7, 0000000 .. 0010111
-				bits = ch - 256; size = 7; break;
-			default:
-				// size 8, 11000000 .. 11000111
-				bits = ch + 192 - 280; size = 8;
+		case ch < 144:
+			// size 8, 000110000  .. 10111111
+			bits = ch+48;
+			size = 8;
+			break;
+		case ch < 256:
+			// size 9, 110010000 .. 111111111
+			bits = ch+400-144;
+			size = 9;
+			break;
+		case ch < 280:
+			// size 7, 0000000 .. 0010111
+			bits = ch-256;
+			size = 7;
+			break;
+		default:
+			// size 8, 11000000 .. 11000111
+			bits = ch+192-280;
+			size = 8;
 		}
 		codeBits[ch] = size;
 		code[ch] = reverseBits(bits, size);
@@ -103,14 +110,14 @@ func generateFixedOffsetEncoding() *huffmanEncoder {
 	return h;
 }
 
-var fixedLiteralEncoding *huffmanEncoder = generateFixedLiteralEncoding();
-var fixedOffsetEncoding *huffmanEncoder = generateFixedOffsetEncoding();
+var fixedLiteralEncoding *huffmanEncoder = generateFixedLiteralEncoding()
+var fixedOffsetEncoding *huffmanEncoder = generateFixedOffsetEncoding()
 
 func (h *huffmanEncoder) bitLength(freq []int32) int64 {
 	var total int64;
 	for i, f := range freq {
 		if f != 0 {
-			total += int64(f) * int64(h.codeBits[i]);
+			total += int64(f)*int64(h.codeBits[i]);
 		}
 	}
 	return total;
@@ -119,7 +126,7 @@ func (h *huffmanEncoder) bitLength(freq []int32) int64 {
 // Generate elements in the chain using an iterative algorithm.
 func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
 	n := len(list);
-	list = list[0:n+1];
+	list = list[0 : n+1];
 	list[n] = maxNode();
 
 	l := top;
@@ -140,13 +147,13 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
 		if l.nextCharFreq < l.nextPairFreq {
 			// The next item on this row is a leaf node.
 			n := l.lastChain.leafCount + 1;
-			l.lastChain = &chain{ l.nextCharFreq, n, l.lastChain.up };
+			l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up};
 			l.nextCharFreq = list[n].freq;
 		} else {
 			// The next item on this row is a pair from the previous row.
 			// nextPairFreq isn't valid until we generate two
 			// more values in the level below
-			l.lastChain = &chain{ l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain };
+			l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain};
 			l.down.needed = 2;
 		}
 
@@ -185,19 +192,19 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
 //             that should be encoded in i bits.
 func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
 	n := int32(len(list));
-	list = list[0:n+1];
+	list = list[0 : n+1];
 	list[n] = maxNode();
 
 	// The tree can't have greater depth than n - 1, no matter what.  This
 	// saves a little bit of work in some small cases
-	maxBits = minInt32(maxBits, n - 1);
+	maxBits = minInt32(maxBits, n-1);
 
 	// Create information about each of the levels.
 	// A bogus "Level 0" whose sole purpose is so that
 	// level1.prev.needed==0.  This makes level1.nextPairFreq
 	// be a legitimate value that never gets chosen.
 	top := &levelInfo{needed: 0};
-	chain2 := &chain{ list[1].freq, 2, new(chain) };
+	chain2 := &chain{list[1].freq, 2, new(chain)};
 	for level := int32(1); level <= maxBits; level++ {
 		// For every level, the first two items are the first two characters.
 		// We initialize the levels as if we had already figured this out.
@@ -235,13 +242,13 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
 		if l.nextCharFreq < l.nextPairFreq {
 			// The next item on this row is a leaf node.
 			n := l.lastChain.leafCount + 1;
-			l.lastChain = &chain{ l.nextCharFreq, n, l.lastChain.up };
+			l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up};
 			l.nextCharFreq = list[n].freq;
 		} else {
 			// The next item on this row is a pair from the previous row.
 			// nextPairFreq isn't valid until we generate two
 			// more values in the level below
-			l.lastChain = &chain{ l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain };
+			l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain};
 			l.down.needed = 2;
 		}
 
@@ -272,7 +279,7 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
 		panic("top.lastChain.leafCount != n");
 	}
 
-	bitCount := make([]int32, maxBits + 1);
+	bitCount := make([]int32, maxBits+1);
 	bits := 1;
 	for chain := top.lastChain; chain.up != nil; chain = chain.up {
 		// chain.leafCount gives the number of literals requiring at least "bits"
@@ -296,14 +303,14 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
 		// are encoded using "bits" bits, and get the values
 		// code, code + 1, ....  The code values are
 		// assigned in literal order (not frequency order).
-		chunk := list[len(list)-int(bits):len(list)];
+		chunk := list[len(list)-int(bits) : len(list)];
 		sortByLiteral(chunk);
 		for _, node := range chunk {
 			h.codeBits[node.literal] = uint8(n);
 			h.code[node.literal] = reverseBits(code, uint8(n));
 			code++;
 		}
-		list = list[0:len(list)-int(bits)];
+		list = list[0 : len(list)-int(bits)];
 	}
 }
 
@@ -312,7 +319,7 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
 // freq  An array of frequencies, in which frequency[i] gives the frequency of literal i.
 // maxBits  The maximum number of bits to use for any literal.
 func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
-	list := make([]literalNode, len(freq) + 1);
+	list := make([]literalNode, len(freq)+1);
 	// Number of non-zero literals
 	count := 0;
 	// Set list to be the set of all non-zero literals and their frequencies
@@ -335,7 +342,7 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
 			h.codeBits[node.literal] = 1;
 			h.code[node.literal] = uint16(i);
 		}
-                return;
+		return;
 	}
 	sortByFreq(list);
 
@@ -346,8 +353,8 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
 }
 
 type literalNodeSorter struct {
-	a []literalNode;
-	less func(i,j int) bool;
+	a	[]literalNode;
+	less	func(i, j int) bool;
 }
 
 func (s literalNodeSorter) Len() int {
@@ -358,16 +365,16 @@ func (s literalNodeSorter) Less(i, j int) bool {
 	return s.less(i, j);
 }
 
-func (s literalNodeSorter) Swap(i,j int) {
+func (s literalNodeSorter) Swap(i, j int) {
 	s.a[i], s.a[j] = s.a[j], s.a[i];
 }
 
 func sortByFreq(a []literalNode) {
-	s := &literalNodeSorter { a, func(i, j int) bool { return a[i].freq < a[j].freq; }};
+	s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }};
 	sort.Sort(s);
 }
 
 func sortByLiteral(a []literalNode) {
-	s := &literalNodeSorter{ a, func(i, j int) bool { return a[i].literal < a[j].literal; }};
+	s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }};
 	sort.Sort(s);
 }

src/pkg/compress/flate/inflate.go

@@ -609,8 +609,6 @@ func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error {
 func NewInflater(r io.Reader) io.ReadCloser {
 	var f inflater;
 	pr, pw := io.Pipe();
-	go func() {
-		pw.CloseWithError(f.inflater(r, pw));
-	}();
+	go func() { pw.CloseWithError(f.inflater(r, pw)) }();
 	return pr;
 }