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

@@ -56,11 +56,11 @@ type levelInfo struct {
 }
 
 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
@@ -75,16 +75,23 @@ func generateFixedLiteralEncoding() *huffmanEncoder {
 		switch {
 		case ch < 144:
 			// size 8, 000110000  .. 10111111
-				bits = ch + 48; size = 8; break;
+			bits = ch+48;
+			size = 8;
+			break;
 		case ch < 256:
 			// size 9, 110010000 .. 111111111
-				bits = ch + 400 - 144; size = 9; break;
+			bits = ch+400-144;
+			size = 9;
+			break;
 		case ch < 280:
 			// size 7, 0000000 .. 0010111
-				bits = ch - 256; size = 7; break;
+			bits = ch-256;
+			size = 7;
+			break;
 		default:
 			// size 8, 11000000 .. 11000111
-				bits = ch + 192 - 280; size = 8;
+			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
@@ -347,7 +354,7 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
 
 type literalNodeSorter struct {
 	a	[]literalNode;
-	less func(i,j int) bool;
+	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;
 }