summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/pkg/compress/flate/huffman_bit_writer.go8
-rw-r--r--src/pkg/compress/flate/huffman_code.go105
-rw-r--r--src/pkg/compress/flate/inflate.go4
3 files changed, 61 insertions, 56 deletions
diff --git a/src/pkg/compress/flate/huffman_bit_writer.go b/src/pkg/compress/flate/huffman_bit_writer.go
index 74c21bd2f..e81c6e6e0 100644
--- a/src/pkg/compress/flate/huffman_bit_writer.go
+++ b/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.
diff --git a/src/pkg/compress/flate/huffman_code.go b/src/pkg/compress/flate/huffman_code.go
index 0efd3e845..8929697bc 100644
--- a/src/pkg/compress/flate/huffman_code.go
+++ b/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);
}
diff --git a/src/pkg/compress/flate/inflate.go b/src/pkg/compress/flate/inflate.go
index 302cbd376..149cb08c7 100644
--- a/src/pkg/compress/flate/inflate.go
+++ b/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;
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-13 18:48:22 +0000