summaryrefslogtreecommitdiff
path: root/src/pkg/compress
diff options
context:
space:
mode:
authorRobert Griesemer <gri@golang.org>2009-12-15 15:33:31 -0800
committerRobert Griesemer <gri@golang.org>2009-12-15 15:33:31 -0800
commitd9527dd16f72598b54a64550607bf892efa12384 (patch)
tree2ad16a7db2d3c484b47426ad2568359ab633820c /src/pkg/compress
parentaea97e0bd7da9cef1cc631ddbd3578a0877a4fcc (diff)
downloadgolang-d9527dd16f72598b54a64550607bf892efa12384.tar.gz
1) Change default gofmt default settings for
parsing and printing to new syntax. Use -oldparser to parse the old syntax, use -oldprinter to print the old syntax. 2) Change default gofmt formatting settings to use tabs for indentation only and to use spaces for alignment. This will make the code alignment insensitive to an editor's tabwidth. Use -spaces=false to use tabs for alignment. 3) Manually changed src/exp/parser/parser_test.go so that it doesn't try to parse the parser's source files using the old syntax (they have new syntax now). 4) gofmt -w src misc test/bench 1st set of files. R=rsc CC=agl, golang-dev, iant, ken2, r http://codereview.appspot.com/180047
Diffstat (limited to 'src/pkg/compress')
-rw-r--r--src/pkg/compress/flate/deflate.go304
-rw-r--r--src/pkg/compress/flate/deflate_test.go60
-rw-r--r--src/pkg/compress/flate/flate_test.go24
-rw-r--r--src/pkg/compress/flate/huffman_bit_writer.go378
-rw-r--r--src/pkg/compress/flate/huffman_code.go240
-rw-r--r--src/pkg/compress/flate/inflate.go340
-rw-r--r--src/pkg/compress/flate/token.go26
-rw-r--r--src/pkg/compress/flate/util.go14
-rw-r--r--src/pkg/compress/gzip/gunzip.go142
-rw-r--r--src/pkg/compress/gzip/gunzip_test.go54
-rw-r--r--src/pkg/compress/zlib/reader.go58
-rw-r--r--src/pkg/compress/zlib/reader_test.go34
-rw-r--r--src/pkg/compress/zlib/writer.go68
-rw-r--r--src/pkg/compress/zlib/writer_test.go86
14 files changed, 914 insertions, 914 deletions
diff --git a/src/pkg/compress/flate/deflate.go b/src/pkg/compress/flate/deflate.go
index d07e46525..18bb353d2 100644
--- a/src/pkg/compress/flate/deflate.go
+++ b/src/pkg/compress/flate/deflate.go
@@ -5,55 +5,55 @@
package flate
import (
- "io";
- "math";
- "os";
+ "io"
+ "math"
+ "os"
)
const (
- NoCompression = 0;
- BestSpeed = 1;
- fastCompression = 3;
- BestCompression = 9;
- DefaultCompression = -1;
- logMaxOffsetSize = 15; // Standard DEFLATE
- wideLogMaxOffsetSize = 22; // Wide DEFLATE
- minMatchLength = 3; // The smallest match that the deflater looks for
- maxMatchLength = 258; // The longest match for the deflater
- minOffsetSize = 1; // The shortest offset that makes any sence
+ NoCompression = 0
+ BestSpeed = 1
+ fastCompression = 3
+ BestCompression = 9
+ DefaultCompression = -1
+ logMaxOffsetSize = 15 // Standard DEFLATE
+ wideLogMaxOffsetSize = 22 // Wide DEFLATE
+ minMatchLength = 3 // The smallest match that the deflater looks for
+ maxMatchLength = 258 // The longest match for the deflater
+ minOffsetSize = 1 // The shortest offset that makes any sence
// The maximum number of tokens we put into a single flat block, just too
// stop things from getting too large.
- maxFlateBlockTokens = 1 << 14;
- maxStoreBlockSize = 65535;
- hashBits = 15;
- hashSize = 1 << hashBits;
- hashMask = (1 << hashBits) - 1;
- hashShift = (hashBits + minMatchLength - 1) / minMatchLength;
+ maxFlateBlockTokens = 1 << 14
+ maxStoreBlockSize = 65535
+ hashBits = 15
+ hashSize = 1 << hashBits
+ hashMask = (1 << hashBits) - 1
+ hashShift = (hashBits + minMatchLength - 1) / minMatchLength
)
type syncPipeReader struct {
- *io.PipeReader;
- closeChan chan bool;
+ *io.PipeReader
+ closeChan chan bool
}
func (sr *syncPipeReader) CloseWithError(err os.Error) os.Error {
- retErr := sr.PipeReader.CloseWithError(err);
- sr.closeChan <- true; // finish writer close
- return retErr;
+ retErr := sr.PipeReader.CloseWithError(err)
+ sr.closeChan <- true // finish writer close
+ return retErr
}
type syncPipeWriter struct {
- *io.PipeWriter;
- closeChan chan bool;
+ *io.PipeWriter
+ closeChan chan bool
}
type compressionLevel struct {
- good, lazy, nice, chain, fastSkipHashing int;
+ good, lazy, nice, chain, fastSkipHashing int
}
var levels = []compressionLevel{
- compressionLevel{}, // 0
+ compressionLevel{}, // 0
// For levels 1-3 we don't bother trying with lazy matches
compressionLevel{3, 0, 8, 4, 4},
compressionLevel{3, 0, 16, 8, 5},
@@ -69,67 +69,67 @@ var levels = []compressionLevel{
}
func (sw *syncPipeWriter) Close() os.Error {
- err := sw.PipeWriter.Close();
- <-sw.closeChan; // wait for reader close
- return err;
+ err := sw.PipeWriter.Close()
+ <-sw.closeChan // wait for reader close
+ return err
}
func syncPipe() (*syncPipeReader, *syncPipeWriter) {
- r, w := io.Pipe();
- sr := &syncPipeReader{r, make(chan bool, 1)};
- sw := &syncPipeWriter{w, sr.closeChan};
- return sr, sw;
+ r, w := io.Pipe()
+ sr := &syncPipeReader{r, make(chan bool, 1)}
+ sw := &syncPipeWriter{w, sr.closeChan}
+ return sr, sw
}
type deflater struct {
- level int;
- logWindowSize uint;
- w *huffmanBitWriter;
- r io.Reader;
+ level int
+ logWindowSize uint
+ w *huffmanBitWriter
+ r io.Reader
// (1 << logWindowSize) - 1.
- windowMask int;
+ windowMask int
// hashHead[hashValue] contains the largest inputIndex with the specified hash value
- hashHead []int;
+ hashHead []int
// If hashHead[hashValue] is within the current window, then
// hashPrev[hashHead[hashValue] & windowMask] contains the previous index
// with the same hash value.
- hashPrev []int;
+ hashPrev []int
// If we find a match of length >= niceMatch, then we don't bother searching
// any further.
- niceMatch int;
+ niceMatch int
// If we find a match of length >= goodMatch, we only do a half-hearted
// effort at doing lazy matching starting at the next character
- goodMatch int;
+ goodMatch int
// The maximum number of chains we look at when finding a match
- maxChainLength int;
+ maxChainLength int
// The sliding window we use for matching
- window []byte;
+ window []byte
// The index just past the last valid character
- windowEnd int;
+ windowEnd int
// index in "window" at which current block starts
- blockStart int;
+ blockStart int
}
func (d *deflater) flush() os.Error {
- d.w.flush();
- return d.w.err;
+ d.w.flush()
+ return d.w.err
}
func (d *deflater) fillWindow(index int) (int, os.Error) {
- wSize := d.windowMask + 1;
+ wSize := d.windowMask + 1
if index >= wSize+wSize-(minMatchLength+maxMatchLength) {
// shift the window by wSize
- copy(d.window, d.window[wSize:2*wSize]);
- index -= wSize;
- d.windowEnd -= wSize;
+ copy(d.window, d.window[wSize:2*wSize])
+ index -= wSize
+ d.windowEnd -= wSize
if d.blockStart >= wSize {
d.blockStart -= wSize
} else {
@@ -142,66 +142,66 @@ func (d *deflater) fillWindow(index int) (int, os.Error) {
d.hashPrev[i] = max(h-wSize, -1)
}
}
- var count int;
- var err os.Error;
- count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:], 1);
- d.windowEnd += count;
+ var count int
+ var err os.Error
+ count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:], 1)
+ d.windowEnd += count
if err == os.EOF {
return index, nil
}
- return index, err;
+ return index, err
}
func (d *deflater) writeBlock(tokens []token, index int, eof bool) os.Error {
if index > 0 || eof {
- var window []byte;
+ var window []byte
if d.blockStart <= index {
window = d.window[d.blockStart:index]
}
- d.blockStart = index;
- d.w.writeBlock(tokens, eof, window);
- return d.w.err;
+ d.blockStart = index
+ d.w.writeBlock(tokens, eof, window)
+ return d.w.err
}
- return nil;
+ return nil
}
// Try to find a match starting at index whose length is greater than prevSize.
// We only look at chainCount possibilities before giving up.
func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead int) (length, offset int, ok bool) {
- win := d.window[0 : pos+min(maxMatchLength, lookahead)];
+ win := d.window[0 : pos+min(maxMatchLength, lookahead)]
// We quit when we get a match that's at least nice long
- nice := min(d.niceMatch, len(win)-pos);
+ nice := min(d.niceMatch, len(win)-pos)
// If we've got a match that's good enough, only look in 1/4 the chain.
- tries := d.maxChainLength;
- length = prevLength;
+ tries := d.maxChainLength
+ length = prevLength
if length >= d.goodMatch {
tries >>= 2
}
- w0 := win[pos];
- w1 := win[pos+1];
- wEnd := win[pos+length];
- minIndex := pos - (d.windowMask + 1);
+ w0 := win[pos]
+ w1 := win[pos+1]
+ wEnd := win[pos+length]
+ minIndex := pos - (d.windowMask + 1)
for i := prevHead; tries > 0; tries-- {
if w0 == win[i] && w1 == win[i+1] && wEnd == win[i+length] {
// The hash function ensures that if win[i] and win[i+1] match, win[i+2] matches
- n := 3;
+ n := 3
for pos+n < len(win) && win[i+n] == win[pos+n] {
n++
}
if n > length && (n > 3 || pos-i <= 4096) {
- length = n;
- offset = pos - i;
- ok = true;
+ length = n
+ offset = pos - i
+ ok = true
if n >= nice {
// The match is good enough that we don't try to find a better one.
break
}
- wEnd = win[pos+n];
+ wEnd = win[pos+n]
}
}
if i == minIndex {
@@ -212,21 +212,21 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in
break
}
}
- return;
+ return
}
func (d *deflater) writeStoredBlock(buf []byte) os.Error {
if d.w.writeStoredHeader(len(buf), false); d.w.err != nil {
return d.w.err
}
- d.w.writeBytes(buf);
- return d.w.err;
+ d.w.writeBytes(buf)
+ return d.w.err
}
func (d *deflater) storedDeflate() os.Error {
- buf := make([]byte, maxStoreBlockSize);
+ buf := make([]byte, maxStoreBlockSize)
for {
- n, err := d.r.Read(buf);
+ n, err := d.r.Read(buf)
if n > 0 {
if err := d.writeStoredBlock(buf[0:n]); err != nil {
return err
@@ -236,83 +236,83 @@ func (d *deflater) storedDeflate() os.Error {
if err == os.EOF {
break
}
- return err;
+ return err
}
}
- return nil;
+ return nil
}
func (d *deflater) doDeflate() (err os.Error) {
// init
- d.windowMask = 1<<d.logWindowSize - 1;
- d.hashHead = make([]int, hashSize);
- d.hashPrev = make([]int, 1<<d.logWindowSize);
- d.window = make([]byte, 2<<d.logWindowSize);
- fillInts(d.hashHead, -1);
- tokens := make([]token, maxFlateBlockTokens, maxFlateBlockTokens+1);
- l := levels[d.level];
- d.goodMatch = l.good;
- d.niceMatch = l.nice;
- d.maxChainLength = l.chain;
- lazyMatch := l.lazy;
- length := minMatchLength - 1;
- offset := 0;
- byteAvailable := false;
- isFastDeflate := l.fastSkipHashing != 0;
- index := 0;
+ d.windowMask = 1<<d.logWindowSize - 1
+ d.hashHead = make([]int, hashSize)
+ d.hashPrev = make([]int, 1<<d.logWindowSize)
+ d.window = make([]byte, 2<<d.logWindowSize)
+ fillInts(d.hashHead, -1)
+ tokens := make([]token, maxFlateBlockTokens, maxFlateBlockTokens+1)
+ l := levels[d.level]
+ d.goodMatch = l.good
+ d.niceMatch = l.nice
+ d.maxChainLength = l.chain
+ lazyMatch := l.lazy
+ length := minMatchLength - 1
+ offset := 0
+ byteAvailable := false
+ isFastDeflate := l.fastSkipHashing != 0
+ index := 0
// run
if index, err = d.fillWindow(index); err != nil {
return
}
- maxOffset := d.windowMask + 1; // (1 << logWindowSize);
+ maxOffset := d.windowMask + 1 // (1 << logWindowSize);
// only need to change when you refill the window
- windowEnd := d.windowEnd;
- maxInsertIndex := windowEnd - (minMatchLength - 1);
- ti := 0;
+ windowEnd := d.windowEnd
+ maxInsertIndex := windowEnd - (minMatchLength - 1)
+ ti := 0
- hash := int(0);
+ hash := int(0)
if index < maxInsertIndex {
hash = int(d.window[index])<<hashShift + int(d.window[index+1])
}
- chainHead := -1;
+ chainHead := -1
for {
if index > windowEnd {
panic("index > windowEnd")
}
- lookahead := windowEnd - index;
+ lookahead := windowEnd - index
if lookahead < minMatchLength+maxMatchLength {
if index, err = d.fillWindow(index); err != nil {
return
}
- windowEnd = d.windowEnd;
+ windowEnd = d.windowEnd
if index > windowEnd {
panic("index > windowEnd")
}
- maxInsertIndex = windowEnd - (minMatchLength - 1);
- lookahead = windowEnd - index;
+ maxInsertIndex = windowEnd - (minMatchLength - 1)
+ lookahead = windowEnd - index
if lookahead == 0 {
break
}
}
if index < maxInsertIndex {
// Update the hash
- hash = (hash<<hashShift + int(d.window[index+2])) & hashMask;
- chainHead = d.hashHead[hash];
- d.hashPrev[index&d.windowMask] = chainHead;
- d.hashHead[hash] = index;
+ hash = (hash<<hashShift + int(d.window[index+2])) & hashMask
+ chainHead = d.hashHead[hash]
+ d.hashPrev[index&d.windowMask] = chainHead
+ d.hashHead[hash] = index
}
- prevLength := length;
- prevOffset := offset;
- minIndex := max(index-maxOffset, 0);
- length = minMatchLength - 1;
- offset = 0;
+ prevLength := length
+ prevOffset := offset
+ minIndex := max(index-maxOffset, 0)
+ length = minMatchLength - 1
+ offset = 0
if chainHead >= minIndex &&
(isFastDeflate && lookahead > minMatchLength-1 ||
!isFastDeflate && lookahead > prevLength && prevLength < lazyMatch) {
if newLength, newOffset, ok := d.findMatch(index, chainHead, minMatchLength-1, lookahead); ok {
- length = newLength;
- offset = newOffset;
+ length = newLength
+ offset = newOffset
}
}
if isFastDeflate && length >= minMatchLength ||
@@ -324,13 +324,13 @@ func (d *deflater) doDeflate() (err os.Error) {
} else {
tokens[ti] = matchToken(uint32(prevLength-minMatchLength), uint32(prevOffset-minOffsetSize))
}
- ti++;
+ ti++
// Insert in the hash table all strings up to the end of the match.
// index and index-1 are already inserted. If there is not enough
// lookahead, the last two strings are not inserted into the hash
// table.
if length <= l.fastSkipHashing {
- var newIndex int;
+ var newIndex int
if isFastDeflate {
newIndex = index + length
} else {
@@ -338,47 +338,47 @@ func (d *deflater) doDeflate() (err os.Error) {
}
for index++; index < newIndex; index++ {
if index < maxInsertIndex {
- hash = (hash<<hashShift + int(d.window[index+2])) & hashMask;
+ hash = (hash<<hashShift + int(d.window[index+2])) & hashMask
// Get previous value with the same hash.
// Our chain should point to the previous value.
- d.hashPrev[index&d.windowMask] = d.hashHead[hash];
+ d.hashPrev[index&d.windowMask] = d.hashHead[hash]
// Set the head of the hash chain to us.
- d.hashHead[hash] = index;
+ d.hashHead[hash] = index
}
}
if !isFastDeflate {
- byteAvailable = false;
- length = minMatchLength - 1;
+ byteAvailable = false
+ length = minMatchLength - 1
}
} else {
// For matches this long, we don't bother inserting each individual
// item into the table.
- index += length;
- hash = (int(d.window[index])<<hashShift + int(d.window[index+1]));
+ index += length
+ hash = (int(d.window[index])<<hashShift + int(d.window[index+1]))
}
if ti == maxFlateBlockTokens {
// The block includes the current character
if err = d.writeBlock(tokens, index, false); err != nil {
return
}
- ti = 0;
+ ti = 0
}
} else {
if isFastDeflate || byteAvailable {
- i := index - 1;
+ i := index - 1
if isFastDeflate {
i = index
}
- tokens[ti] = literalToken(uint32(d.window[i]) & 0xFF);
- ti++;
+ tokens[ti] = literalToken(uint32(d.window[i]) & 0xFF)
+ ti++
if ti == maxFlateBlockTokens {
if err = d.writeBlock(tokens, i+1, false); err != nil {
return
}
- ti = 0;
+ ti = 0
}
}
- index++;
+ index++
if !isFastDeflate {
byteAvailable = true
}
@@ -387,8 +387,8 @@ func (d *deflater) doDeflate() (err os.Error) {
}
if byteAvailable {
// There is still one pending token that needs to be flushed
- tokens[ti] = literalToken(uint32(d.window[index-1]) & 0xFF);
- ti++;
+ tokens[ti] = literalToken(uint32(d.window[index-1]) & 0xFF)
+ ti++
}
if ti > 0 {
@@ -396,21 +396,21 @@ func (d *deflater) doDeflate() (err os.Error) {
return
}
}
- return;
+ return
}
func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize uint) (err os.Error) {
- d.r = r;
- d.w = newHuffmanBitWriter(w);
- d.level = level;
- d.logWindowSize = logWindowSize;
+ d.r = r
+ d.w = newHuffmanBitWriter(w)
+ d.level = level
+ d.logWindowSize = logWindowSize
switch {
case level == NoCompression:
err = d.storedDeflate()
case level == DefaultCompression:
- d.level = 6;
- fallthrough;
+ d.level = 6
+ fallthrough
case 1 <= level && level <= 9:
err = d.doDeflate()
default:
@@ -423,17 +423,17 @@ func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize u
if d.w.writeStoredHeader(0, true); d.w.err != nil {
return d.w.err
}
- return d.flush();
+ return d.flush()
}
func newDeflater(w io.Writer, level int, logWindowSize uint) io.WriteCloser {
- var d deflater;
- pr, pw := syncPipe();
+ var d deflater
+ pr, pw := syncPipe()
go func() {
- err := d.deflater(pr, w, level, logWindowSize);
- pr.CloseWithError(err);
- }();
- return pw;
+ err := d.deflater(pr, w, level, logWindowSize)
+ pr.CloseWithError(err)
+ }()
+ return pw
}
func NewDeflater(w io.Writer, level int) io.WriteCloser {
diff --git a/src/pkg/compress/flate/deflate_test.go b/src/pkg/compress/flate/deflate_test.go
index 9d5ada994..1ac8059b3 100644
--- a/src/pkg/compress/flate/deflate_test.go
+++ b/src/pkg/compress/flate/deflate_test.go
@@ -5,27 +5,27 @@
package flate
import (
- "bytes";
- "fmt";
- "io/ioutil";
- "os";
- "testing";
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "testing"
)
type deflateTest struct {
- in []byte;
- level int;
- out []byte;
+ in []byte
+ level int
+ out []byte
}
type deflateInflateTest struct {
- in []byte;
+ in []byte
}
type reverseBitsTest struct {
- in uint16;
- bitCount uint8;
- out uint16;
+ in uint16
+ bitCount uint8
+ out uint16
}
var deflateTests = []*deflateTest{
@@ -70,19 +70,19 @@ var reverseBitsTests = []*reverseBitsTest{
}
func getLargeDataChunk() []byte {
- result := make([]byte, 100000);
+ result := make([]byte, 100000)
for i := range result {
result[i] = byte(int64(i) * int64(i) & 0xFF)
}
- return result;
+ return result
}
func TestDeflate(t *testing.T) {
for _, h := range deflateTests {
- buffer := bytes.NewBuffer([]byte{});
- w := NewDeflater(buffer, h.level);
- w.Write(h.in);
- w.Close();
+ buffer := bytes.NewBuffer([]byte{})
+ w := NewDeflater(buffer, h.level)
+ w.Write(h.in)
+ w.Close()
if bytes.Compare(buffer.Bytes(), h.out) != 0 {
t.Errorf("buffer is wrong; level = %v, buffer.Bytes() = %v, expected output = %v",
h.level, buffer.Bytes(), h.out)
@@ -91,21 +91,21 @@ func TestDeflate(t *testing.T) {
}
func testToFromWithLevel(t *testing.T, level int, input []byte, name string) os.Error {
- buffer := bytes.NewBuffer([]byte{});
- w := NewDeflater(buffer, level);
- w.Write(input);
- w.Close();
- inflater := NewInflater(buffer);
- decompressed, err := ioutil.ReadAll(inflater);
+ buffer := bytes.NewBuffer([]byte{})
+ w := NewDeflater(buffer, level)
+ w.Write(input)
+ w.Close()
+ inflater := NewInflater(buffer)
+ decompressed, err := ioutil.ReadAll(inflater)
if err != nil {
- t.Errorf("reading inflater: %s", err);
- return err;
+ t.Errorf("reading inflater: %s", err)
+ return err
}
- inflater.Close();
+ inflater.Close()
if bytes.Compare(input, decompressed) != 0 {
t.Errorf("decompress(compress(data)) != data: level=%d input=%s", level, name)
}
- return nil;
+ return nil
}
func testToFrom(t *testing.T, input []byte, name string) {
@@ -130,8 +130,8 @@ func TestReverseBits(t *testing.T) {
}
func TestDeflateInflateString(t *testing.T) {
- gold := bytes.NewBufferString(getEdata()).Bytes();
- testToFromWithLevel(t, 1, gold, "2.718281828...");
+ gold := bytes.NewBufferString(getEdata()).Bytes()
+ testToFromWithLevel(t, 1, gold, "2.718281828...")
}
func getEdata() string {
diff --git a/src/pkg/compress/flate/flate_test.go b/src/pkg/compress/flate/flate_test.go
index e2a97b368..d7a9a3d24 100644
--- a/src/pkg/compress/flate/flate_test.go
+++ b/src/pkg/compress/flate/flate_test.go
@@ -9,9 +9,9 @@
package flate
import (
- "bytes";
- "reflect";
- "testing";
+ "bytes"
+ "reflect"
+ "testing"
)
// The Huffman code lengths used by the fixed-format Huffman blocks.
@@ -45,9 +45,9 @@ var fixedHuffmanBits = [...]int{
}
type InitDecoderTest struct {
- in []int;
- out huffmanDecoder;
- ok bool;
+ in []int
+ out huffmanDecoder
+ ok bool
}
var initDecoderTests = []*InitDecoderTest{
@@ -115,10 +115,10 @@ var initDecoderTests = []*InitDecoderTest{
func TestInitDecoder(t *testing.T) {
for i, tt := range initDecoderTests {
- var h huffmanDecoder;
+ var h huffmanDecoder
if h.init(tt.in) != tt.ok {
- t.Errorf("test %d: init = %v", i, !tt.ok);
- continue;
+ t.Errorf("test %d: init = %v", i, !tt.ok)
+ continue
}
if !reflect.DeepEqual(&h, &tt.out) {
t.Errorf("test %d:\nhave %v\nwant %v", i, h, tt.out)
@@ -127,9 +127,9 @@ func TestInitDecoder(t *testing.T) {
}
func TestUncompressedSource(t *testing.T) {
- decoder := NewInflater(bytes.NewBuffer([]byte{0x01, 0x01, 0x00, 0xfe, 0xff, 0x11}));
- output := make([]byte, 1);
- n, error := decoder.Read(output);
+ decoder := NewInflater(bytes.NewBuffer([]byte{0x01, 0x01, 0x00, 0xfe, 0xff, 0x11}))
+ output := make([]byte, 1)
+ n, error := decoder.Read(output)
if n != 1 || error != nil {
t.Fatalf("decoder.Read() = %d, %v, want 1, nil", n, error)
}
diff --git a/src/pkg/compress/flate/huffman_bit_writer.go b/src/pkg/compress/flate/huffman_bit_writer.go
index a1ef3694c..eac196dfc 100644
--- a/src/pkg/compress/flate/huffman_bit_writer.go
+++ b/src/pkg/compress/flate/huffman_bit_writer.go
@@ -5,28 +5,28 @@
package flate
import (
- "io";
- "math";
- "os";
- "strconv";
+ "io"
+ "math"
+ "os"
+ "strconv"
)
const (
// The largest offset code.
- offsetCodeCount = 30;
+ offsetCodeCount = 30
// The largest offset code in the extensions.
- extendedOffsetCodeCount = 42;
+ extendedOffsetCodeCount = 42
// The special code used to mark the end of a block.
- endBlockMarker = 256;
+ endBlockMarker = 256
// The first length code.
- lengthCodesStart = 257;
+ lengthCodesStart = 257
// The number of codegen codes.
- codegenCodeCount = 19;
- badCode = 255;
+ codegenCodeCount = 19
+ badCode = 255
)
// The number of extra bits needed by length code X - LENGTH_CODES_START.
@@ -72,28 +72,28 @@ var offsetBase = []uint32{
var codegenOrder = []uint32{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}
type huffmanBitWriter struct {
- w io.Writer;
+ w io.Writer
// Data waiting to be written is bytes[0:nbytes]
// and then the low nbits of bits.
- bits uint32;
- nbits uint32;
- bytes [64]byte;
- nbytes int;
- literalFreq []int32;
- offsetFreq []int32;
- codegen []uint8;
- codegenFreq []int32;
- literalEncoding *huffmanEncoder;
- offsetEncoding *huffmanEncoder;
- codegenEncoding *huffmanEncoder;
- err os.Error;
+ bits uint32
+ nbits uint32
+ bytes [64]byte
+ nbytes int
+ literalFreq []int32
+ offsetFreq []int32
+ codegen []uint8
+ codegenFreq []int32
+ literalEncoding *huffmanEncoder
+ offsetEncoding *huffmanEncoder
+ codegenEncoding *huffmanEncoder
+ err os.Error
}
type WrongValueError struct {
- name string;
- from int32;
- to int32;
- value int32;
+ name string
+ from int32
+ to int32
+ value int32
}
func newHuffmanBitWriter(w io.Writer) *huffmanBitWriter {
@@ -116,46 +116,46 @@ func (err WrongValueError) String() string {
func (w *huffmanBitWriter) flushBits() {
if w.err != nil {
- w.nbits = 0;
- return;
- }
- bits := w.bits;
- w.bits >>= 16;
- w.nbits -= 16;
- n := w.nbytes;
- w.bytes[n] = byte(bits);
- w.bytes[n+1] = byte(bits >> 8);
+ w.nbits = 0
+ return
+ }
+ bits := w.bits
+ w.bits >>= 16
+ w.nbits -= 16
+ n := w.nbytes
+ w.bytes[n] = byte(bits)
+ w.bytes[n+1] = byte(bits >> 8)
if n += 2; n >= len(w.bytes) {
- _, w.err = w.w.Write(&w.bytes);
- n = 0;
+ _, w.err = w.w.Write(&w.bytes)
+ n = 0
}
- w.nbytes = n;
+ w.nbytes = n
}
func (w *huffmanBitWriter) flush() {
if w.err != nil {
- w.nbits = 0;
- return;
+ w.nbits = 0
+ return
}
- n := w.nbytes;
+ n := w.nbytes
if w.nbits > 8 {
- w.bytes[n] = byte(w.bits);
- w.bits >>= 8;
- w.nbits -= 8;
- n++;
+ w.bytes[n] = byte(w.bits)
+ w.bits >>= 8
+ w.nbits -= 8
+ n++
}
if w.nbits > 0 {
- w.bytes[n] = byte(w.bits);
- w.nbits = 0;
- n++;
+ w.bytes[n] = byte(w.bits)
+ w.nbits = 0
+ n++
}
- w.bits = 0;
- _, w.err = w.w.Write(w.bytes[0:n]);
- w.nbytes = 0;
+ w.bits = 0
+ _, w.err = w.w.Write(w.bytes[0:n])
+ w.nbytes = 0
}
func (w *huffmanBitWriter) writeBits(b, nb int32) {
- w.bits |= uint32(b) << w.nbits;
+ w.bits |= uint32(b) << w.nbits
if w.nbits += uint32(nb); w.nbits >= 16 {
w.flushBits()
}
@@ -165,24 +165,24 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) {
if w.err != nil {
return
}
- n := w.nbytes;
+ n := w.nbytes
if w.nbits == 8 {
- w.bytes[n] = byte(w.bits);
- w.nbits = 0;
- n++;
+ w.bytes[n] = byte(w.bits)
+ w.nbits = 0
+ n++
}
if w.nbits != 0 {
- w.err = InternalError("writeBytes with unfinished bits");
- return;
+ w.err = InternalError("writeBytes with unfinished bits")
+ return
}
if n != 0 {
- _, w.err = w.w.Write(w.bytes[0:n]);
+ _, w.err = w.w.Write(w.bytes[0:n])
if w.err != nil {
return
}
}
- w.nbytes = 0;
- _, w.err = w.w.Write(bytes);
+ w.nbytes = 0
+ _, w.err = w.w.Write(bytes)
}
// RFC 1951 3.2.7 specifies a special run-length encoding for specifiying
@@ -197,82 +197,82 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) {
// numLiterals The number of literals in literalEncoding
// numOffsets The number of offsets in offsetEncoding
func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int) {
- fillInt32s(w.codegenFreq, 0);
+ fillInt32s(w.codegenFreq, 0)
// Note that we are using codegen both as a temporary variable for holding
// a copy of the frequencies, and as the place where we put the result.
// This is fine because the output is always shorter than the input used
// so far.
- codegen := w.codegen; // cache
+ codegen := w.codegen // cache
// Copy the concatenated code sizes to codegen. Put a marker at the end.
- copyUint8s(codegen[0:numLiterals], w.literalEncoding.codeBits);
- copyUint8s(codegen[numLiterals:numLiterals+numOffsets], w.offsetEncoding.codeBits);
- codegen[numLiterals+numOffsets] = badCode;
+ copyUint8s(codegen[0:numLiterals], w.literalEncoding.codeBits)
+ copyUint8s(codegen[numLiterals:numLiterals+numOffsets], w.offsetEncoding.codeBits)
+ codegen[numLiterals+numOffsets] = badCode
- size := codegen[0];
- count := 1;
- outIndex := 0;
+ size := codegen[0]
+ count := 1
+ outIndex := 0
for inIndex := 1; size != badCode; inIndex++ {
// INVARIANT: We have seen "count" copies of size that have not yet
// had output generated for them.
- nextSize := codegen[inIndex];
+ nextSize := codegen[inIndex]
if nextSize == size {
- count++;
- continue;
+ count++
+ continue
}
// We need to generate codegen indicating "count" of size.
if size != 0 {
- codegen[outIndex] = size;
- outIndex++;
- w.codegenFreq[size]++;
- count--;
+ codegen[outIndex] = size
+ outIndex++
+ w.codegenFreq[size]++
+ count--
for count >= 3 {
- n := min(count, 6);
- codegen[outIndex] = 16;
- outIndex++;
- codegen[outIndex] = uint8(n - 3);
- outIndex++;
- w.codegenFreq[16]++;
- count -= n;
+ n := min(count, 6)
+ codegen[outIndex] = 16
+ outIndex++
+ codegen[outIndex] = uint8(n - 3)
+ outIndex++
+ w.codegenFreq[16]++
+ count -= n
}
} else {
for count >= 11 {
- n := min(count, 138);
- codegen[outIndex] = 18;
- outIndex++;
- codegen[outIndex] = uint8(n - 11);
- outIndex++;
- w.codegenFreq[18]++;
- count -= n;
+ n := min(count, 138)
+ codegen[outIndex] = 18
+ outIndex++
+ codegen[outIndex] = uint8(n - 11)
+ outIndex++
+ w.codegenFreq[18]++
+ count -= n
}
if count >= 3 {
// count >= 3 && count <= 10
- codegen[outIndex] = 17;
- outIndex++;
- codegen[outIndex] = uint8(count - 3);
- outIndex++;
- w.codegenFreq[17]++;
- count = 0;
+ codegen[outIndex] = 17
+ outIndex++
+ codegen[outIndex] = uint8(count - 3)
+ outIndex++
+ w.codegenFreq[17]++
+ count = 0
}
}
- count--;
+ count--
for ; count >= 0; count-- {
- codegen[outIndex] = size;
- outIndex++;
- w.codegenFreq[size]++;
+ codegen[outIndex] = size
+ outIndex++
+ w.codegenFreq[size]++
}
// Set up invariant for next time through the loop.
- size = nextSize;
- count = 1;
+ size = nextSize
+ count = 1
}
// Marker indicating the end of the codegen.
- codegen[outIndex] = badCode;
+ codegen[outIndex] = badCode
}
func (w *huffmanBitWriter) writeCode(code *huffmanEncoder, literal uint32) {
if w.err != nil {
return
}
- w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal]));
+ w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal]))
}
// Write the header of a dynamic Huffman block to the output stream.
@@ -284,49 +284,49 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
if w.err != nil {
return
}
- var firstBits int32 = 4;
+ var firstBits int32 = 4
if isEof {
firstBits = 5
}
- w.writeBits(firstBits, 3);
- w.writeBits(int32(numLiterals-257), 5);
+ w.writeBits(firstBits, 3)
+ w.writeBits(int32(numLiterals-257), 5)
if numOffsets > offsetCodeCount {
// Extended version of deflater
- w.writeBits(int32(offsetCodeCount+((numOffsets-(1+offsetCodeCount))>>3)), 5);
- w.writeBits(int32((numOffsets-(1+offsetCodeCount))&0x7), 3);
+ w.writeBits(int32(offsetCodeCount+((numOffsets-(1+offsetCodeCount))>>3)), 5)
+ w.writeBits(int32((numOffsets-(1+offsetCodeCount))&0x7), 3)
} else {
w.writeBits(int32(numOffsets-1), 5)
}
- w.writeBits(int32(numCodegens-4), 4);
+ w.writeBits(int32(numCodegens-4), 4)
for i := 0; i < numCodegens; i++ {
- value := w.codegenEncoding.codeBits[codegenOrder[i]];
- w.writeBits(int32(value), 3);
+ value := w.codegenEncoding.codeBits[codegenOrder[i]]
+ w.writeBits(int32(value), 3)
}
- i := 0;
+ i := 0
for {
- var codeWord int = int(w.codegen[i]);
- i++;
+ var codeWord int = int(w.codegen[i])
+ i++
if codeWord == badCode {
break
}
// The low byte contains the actual code to generate.
- w.writeCode(w.codegenEncoding, uint32(codeWord));
+ w.writeCode(w.codegenEncoding, uint32(codeWord))
switch codeWord {
case 16:
- w.writeBits(int32(w.codegen[i]), 2);
- i++;
- break;
+ w.writeBits(int32(w.codegen[i]), 2)
+ i++
+ break
case 17:
- w.writeBits(int32(w.codegen[i]), 3);
- i++;
- break;
+ w.writeBits(int32(w.codegen[i]), 3)
+ i++
+ break
case 18:
- w.writeBits(int32(w.codegen[i]), 7);
- i++;
- break;
+ w.writeBits(int32(w.codegen[i]), 7)
+ i++
+ break
}
}
}
@@ -335,14 +335,14 @@ func (w *huffmanBitWriter) writeStoredHeader(length int, isEof bool) {
if w.err != nil {
return
}
- var flag int32;
+ var flag int32
if isEof {
flag = 1
}
- w.writeBits(flag, 3);
- w.flush();
- w.writeBits(int32(length), 16);
- w.writeBits(int32(^uint16(length)), 16);
+ w.writeBits(flag, 3)
+ w.flush()
+ w.writeBits(int32(length), 16)
+ w.writeBits(int32(^uint16(length)), 16)
}
func (w *huffmanBitWriter) writeFixedHeader(isEof bool) {
@@ -350,61 +350,61 @@ func (w *huffmanBitWriter) writeFixedHeader(isEof bool) {
return
}
// Indicate that we are a fixed Huffman block
- var value int32 = 2;
+ var value int32 = 2
if isEof {
value = 3
}
- w.writeBits(value, 3);
+ w.writeBits(value, 3)
}
func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
if w.err != nil {
return
}
- fillInt32s(w.literalFreq, 0);
- fillInt32s(w.offsetFreq, 0);
+ fillInt32s(w.literalFreq, 0)
+ fillInt32s(w.offsetFreq, 0)
- n := len(tokens);
- tokens = tokens[0 : n+1];
- tokens[n] = endBlockMarker;
+ n := len(tokens)
+ tokens = tokens[0 : n+1]
+ tokens[n] = endBlockMarker
- totalLength := -1; // Subtract 1 for endBlock.
+ totalLength := -1 // Subtract 1 for endBlock.
for _, t := range tokens {
switch t.typ() {
case literalType:
- w.literalFreq[t.literal()]++;
- totalLength++;
- break;
+ w.literalFreq[t.literal()]++
+ totalLength++
+ break
case matchType:
- length := t.length();
- offset := t.offset();
- totalLength += int(length + 3);
- w.literalFreq[lengthCodesStart+lengthCode(length)]++;
- w.offsetFreq[offsetCode(offset)]++;
- break;
+ length := t.length()
+ offset := t.offset()
+ totalLength += int(length + 3)
+ w.literalFreq[lengthCodesStart+lengthCode(length)]++
+ w.offsetFreq[offsetCode(offset)]++
+ break
}
}
- w.literalEncoding.generate(w.literalFreq, 15);
- w.offsetEncoding.generate(w.offsetFreq, 15);
+ w.literalEncoding.generate(w.literalFreq, 15)
+ w.offsetEncoding.generate(w.offsetFreq, 15)
// get the number of literals
- numLiterals := len(w.literalFreq);
+ numLiterals := len(w.literalFreq)
for w.literalFreq[numLiterals-1] == 0 {
numLiterals--
}
// get the number of offsets
- numOffsets := len(w.offsetFreq);
+ numOffsets := len(w.offsetFreq)
for numOffsets > 1 && w.offsetFreq[numOffsets-1] == 0 {
numOffsets--
}
- storedBytes := 0;
+ storedBytes := 0
if input != nil {
storedBytes = len(input)
}
- var extraBits int64;
- var storedSize int64;
+ var extraBits int64
+ var storedSize int64
if storedBytes <= maxStoreBlockSize && input != nil {
- storedSize = int64((storedBytes + 5) * 8);
+ storedSize = int64((storedBytes + 5) * 8)
// We only bother calculating the costs of the extra bits required by
// the length of offset fields (which will be the same for both fixed
// and dynamic encoding), if we need to compare those two encodings
@@ -423,7 +423,7 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
// Figure out which generates smaller code, fixed Huffman, dynamic
// Huffman, or just storing the data.
- var fixedSize int64 = math.MaxInt64;
+ var fixedSize int64 = math.MaxInt64
if numOffsets <= offsetCodeCount {
fixedSize = int64(3) +
fixedLiteralEncoding.bitLength(w.literalFreq) +
@@ -432,13 +432,13 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
}
// Generate codegen and codegenFrequencies, which indicates how to encode
// the literalEncoding and the offsetEncoding.
- w.generateCodegen(numLiterals, numOffsets);
- w.codegenEncoding.generate(w.codegenFreq, 7);
- numCodegens := len(w.codegenFreq);
+ w.generateCodegen(numLiterals, numOffsets)
+ w.codegenEncoding.generate(w.codegenFreq, 7)
+ numCodegens := len(w.codegenFreq)
for numCodegens > 4 && w.codegenFreq[codegenOrder[numCodegens-1]] == 0 {
numCodegens--
}
- extensionSummand := 0;
+ extensionSummand := 0
if numOffsets > offsetCodeCount {
extensionSummand = 3
}
@@ -449,56 +449,56 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
int64(extraBits) +
int64(w.codegenFreq[16]*2) +
int64(w.codegenFreq[17]*3) +
- int64(w.codegenFreq[18]*7);
+ int64(w.codegenFreq[18]*7)
dynamicSize := dynamicHeader +
w.literalEncoding.bitLength(w.literalFreq) +
- w.offsetEncoding.bitLength(w.offsetFreq);
+ w.offsetEncoding.bitLength(w.offsetFreq)
if storedSize < fixedSize && storedSize < dynamicSize {
- w.writeStoredHeader(storedBytes, eof);
- w.writeBytes(input[0:storedBytes]);
- return;
+ w.writeStoredHeader(storedBytes, eof)
+ w.writeBytes(input[0:storedBytes])
+ return
}
- var literalEncoding *huffmanEncoder;
- var offsetEncoding *huffmanEncoder;
+ var literalEncoding *huffmanEncoder
+ var offsetEncoding *huffmanEncoder
if fixedSize <= dynamicSize {
- w.writeFixedHeader(eof);
- literalEncoding = fixedLiteralEncoding;
- offsetEncoding = fixedOffsetEncoding;
+ w.writeFixedHeader(eof)
+ literalEncoding = fixedLiteralEncoding
+ offsetEncoding = fixedOffsetEncoding
} else {
// Write the header.
- w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof);
- literalEncoding = w.literalEncoding;
- offsetEncoding = w.offsetEncoding;
+ w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof)
+ literalEncoding = w.literalEncoding
+ offsetEncoding = w.offsetEncoding
}
// Write the tokens.
for _, t := range tokens {
switch t.typ() {
case literalType:
- w.writeCode(literalEncoding, t.literal());
- break;
+ w.writeCode(literalEncoding, t.literal())
+ break
case matchType:
// Write the length
- length := t.length();
- lengthCode := lengthCode(length);
- w.writeCode(literalEncoding, lengthCode+lengthCodesStart);
- extraLengthBits := int32(lengthExtraBits[lengthCode]);
+ length := t.length()
+ lengthCode := lengthCode(length)
+ w.writeCode(literalEncoding, lengthCode+lengthCodesStart)
+ extraLengthBits := int32(lengthExtraBits[lengthCode])
if extraLengthBits > 0 {
- extraLength := int32(length - lengthBase[lengthCode]);
- w.writeBits(extraLength, extraLengthBits);
+ extraLength := int32(length - lengthBase[lengthCode])
+ w.writeBits(extraLength, extraLengthBits)
}
// Write the offset
- offset := t.offset();
- offsetCode := offsetCode(offset);
- w.writeCode(offsetEncoding, offsetCode);
- extraOffsetBits := int32(offsetExtraBits[offsetCode]);
+ offset := t.offset()
+ offsetCode := offsetCode(offset)
+ w.writeCode(offsetEncoding, offsetCode)
+ extraOffsetBits := int32(offsetExtraBits[offsetCode])
if extraOffsetBits > 0 {
- extraOffset := int32(offset - offsetBase[offsetCode]);
- w.writeBits(extraOffset, extraOffsetBits);
+ extraOffset := int32(offset - offsetBase[offsetCode])
+ w.writeBits(extraOffset, extraOffsetBits)
}
- break;
+ break
default:
panic("unknown token type: " + string(t))
}
diff --git a/src/pkg/compress/flate/huffman_code.go b/src/pkg/compress/flate/huffman_code.go
index f212d059d..94ff2dfb8 100644
--- a/src/pkg/compress/flate/huffman_code.go
+++ b/src/pkg/compress/flate/huffman_code.go
@@ -5,57 +5,57 @@
package flate
import (
- "math";
- "sort";
+ "math"
+ "sort"
)
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} }
+func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} }
func newHuffmanEncoder(size int) *huffmanEncoder {
return &huffmanEncoder{make([]uint8, size), make([]uint16, size)}
@@ -63,96 +63,96 @@ func newHuffmanEncoder(size int) *huffmanEncoder {
// Generates a HuffmanCode corresponding to the fixed literal table
func generateFixedLiteralEncoding() *huffmanEncoder {
- h := newHuffmanEncoder(maxLit);
- codeBits := h.codeBits;
- code := h.code;
- var ch uint16;
+ h := newHuffmanEncoder(maxLit)
+ codeBits := h.codeBits
+ code := h.code
+ var ch uint16
for ch = 0; ch < maxLit; ch++ {
- var bits uint16;
- var size uint8;
+ var bits uint16
+ var size uint8
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);
+ codeBits[ch] = size
+ code[ch] = reverseBits(bits, size)
}
- return h;
+ return h
}
func generateFixedOffsetEncoding() *huffmanEncoder {
- h := newHuffmanEncoder(30);
- codeBits := h.codeBits;
- code := h.code;
+ h := newHuffmanEncoder(30)
+ codeBits := h.codeBits
+ code := h.code
for ch := uint16(0); ch < 30; ch++ {
- codeBits[ch] = 5;
- code[ch] = reverseBits(ch, 5);
+ codeBits[ch] = 5
+ code[ch] = reverseBits(ch, 5)
}
- return h;
+ return h
}
var fixedLiteralEncoding *huffmanEncoder = generateFixedLiteralEncoding()
var fixedOffsetEncoding *huffmanEncoder = generateFixedOffsetEncoding()
func (h *huffmanEncoder) bitLength(freq []int32) int64 {
- var total int64;
+ var total int64
for i, f := range freq {
if f != 0 {
total += int64(f) * int64(h.codeBits[i])
}
}
- return total;
+ return total
}
// 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[n] = maxNode();
+ n := len(list)
+ list = list[0 : n+1]
+ list[n] = maxNode()
- l := top;
+ l := top
for {
if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
// We've run out of both leafs and pairs.
// End all calculations for this level.
// To m sure we never come back to this level or any lower level,
// set nextPairFreq impossibly large.
- l.lastChain = nil;
- l.needed = 0;
- l = l.up;
- l.nextPairFreq = math.MaxInt32;
- continue;
+ l.lastChain = nil
+ l.needed = 0
+ l = l.up
+ l.nextPairFreq = math.MaxInt32
+ continue
}
- prevFreq := l.lastChain.freq;
+ prevFreq := l.lastChain.freq
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.nextCharFreq = list[n].freq;
+ n := l.lastChain.leafCount + 1
+ 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.down.needed = 2;
+ l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}
+ l.down.needed = 2
}
if l.needed--; l.needed == 0 {
@@ -160,13 +160,13 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
// Continue calculating one level up. Fill in nextPairFreq
// of that level with the sum of the two nodes we've just calculated on
// this level.
- up := l.up;
+ up := l.up
if up == nil {
// All done!
return
}
- up.nextPairFreq = prevFreq + l.lastChain.freq;
- l = up;
+ up.nextPairFreq = prevFreq + l.lastChain.freq
+ l = up
} else {
// If we stole from below, move down temporarily to replenish it.
for l.down.needed > 0 {
@@ -189,20 +189,20 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
// return An integer array in which array[i] indicates the number of literals
// 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[n] = maxNode();
+ n := int32(len(list))
+ 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)};
+ top := &levelInfo{needed: 0}
+ 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.
@@ -212,42 +212,42 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
nextCharFreq: list[2].freq,
nextPairFreq: list[0].freq + list[1].freq,
down: top,
- };
- top.down.up = top;
+ }
+ top.down.up = top
if level == 1 {
top.nextPairFreq = math.MaxInt32
}
}
// We need a total of 2*n - 2 items at top level and have already generated 2.
- top.needed = 2*n - 4;
+ top.needed = 2*n - 4
- l := top;
+ l := top
for {
if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
// We've run out of both leafs and pairs.
// End all calculations for this level.
// To m sure we never come back to this level or any lower level,
// set nextPairFreq impossibly large.
- l.lastChain = nil;
- l.needed = 0;
- l = l.up;
- l.nextPairFreq = math.MaxInt32;
- continue;
+ l.lastChain = nil
+ l.needed = 0
+ l = l.up
+ l.nextPairFreq = math.MaxInt32
+ continue
}
- prevFreq := l.lastChain.freq;
+ prevFreq := l.lastChain.freq
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.nextCharFreq = list[n].freq;
+ n := l.lastChain.leafCount + 1
+ 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.down.needed = 2;
+ l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}
+ l.down.needed = 2
}
if l.needed--; l.needed == 0 {
@@ -255,13 +255,13 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
// Continue calculating one level up. Fill in nextPairFreq
// of that level with the sum of the two nodes we've just calculated on
// this level.
- up := l.up;
+ up := l.up
if up == nil {
// All done!
break
}
- up.nextPairFreq = prevFreq + l.lastChain.freq;
- l = up;
+ up.nextPairFreq = prevFreq + l.lastChain.freq
+ l = up
} else {
// If we stole from below, move down temporarily to replenish it.
for l.down.needed > 0 {
@@ -277,23 +277,23 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
panic("top.lastChain.leafCount != n")
}
- bitCount := make([]int32, maxBits+1);
- bits := 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"
// bits to encode.
- bitCount[bits] = chain.leafCount - chain.up.leafCount;
- bits++;
+ bitCount[bits] = chain.leafCount - chain.up.leafCount
+ bits++
}
- return bitCount;
+ return bitCount
}
// Look at the leaves and assign them a bit count and an encoding as specified
// in RFC 1951 3.2.2
func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalNode) {
- code := uint16(0);
+ code := uint16(0)
for n, bits := range bitCount {
- code <<= 1;
+ code <<= 1
if n == 0 || bits == 0 {
continue
}
@@ -301,14 +301,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):];
- sortByLiteral(chunk);
+ chunk := list[len(list)-int(bits):]
+ sortByLiteral(chunk)
for _, node := range chunk {
- h.codeBits[node.literal] = uint8(n);
- h.code[node.literal] = reverseBits(code, uint8(n));
- code++;
+ 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)]
}
}
@@ -317,58 +317,58 @@ 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;
+ count := 0
// Set list to be the set of all non-zero literals and their frequencies
for i, f := range freq {
if f != 0 {
- list[count] = literalNode{uint16(i), f};
- count++;
+ list[count] = literalNode{uint16(i), f}
+ count++
} else {
h.codeBits[i] = 0
}
}
// If freq[] is shorter than codeBits[], fill rest of codeBits[] with zeros
- h.codeBits = h.codeBits[0:len(freq)];
- list = list[0:count];
+ h.codeBits = h.codeBits[0:len(freq)]
+ list = list[0:count]
if count <= 2 {
// Handle the small cases here, because they are awkward for the general case code. With
// two or fewer literals, everything has bit length 1.
for i, node := range list {
// "list" is in order of increasing literal value.
- h.codeBits[node.literal] = 1;
- h.code[node.literal] = uint16(i);
+ h.codeBits[node.literal] = 1
+ h.code[node.literal] = uint16(i)
}
- return;
+ return
}
- sortByFreq(list);
+ sortByFreq(list)
// Get the number of literals for each bit count
- bitCount := h.bitCounts(list, maxBits);
+ bitCount := h.bitCounts(list, maxBits)
// And do the assignment
- h.assignEncodingAndSize(bitCount, list);
+ h.assignEncodingAndSize(bitCount, list)
}
type literalNodeSorter struct {
- a []literalNode;
- less func(i, j int) bool;
+ a []literalNode
+ less func(i, j int) bool
}
-func (s literalNodeSorter) Len() int { return len(s.a) }
+func (s literalNodeSorter) Len() int { return len(s.a) }
func (s literalNodeSorter) Less(i, j int) bool {
return s.less(i, j)
}
-func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
+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 }};
- sort.Sort(s);
+ 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 }};
- sort.Sort(s);
+ 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 213846688..371fe94c5 100644
--- a/src/pkg/compress/flate/inflate.go
+++ b/src/pkg/compress/flate/inflate.go
@@ -8,18 +8,18 @@
package flate
import (
- "bufio";
- "io";
- "os";
- "strconv";
+ "bufio"
+ "io"
+ "os"
+ "strconv"
)
const (
- maxCodeLen = 16; // max length of Huffman code
- maxHist = 32768; // max history required
- maxLit = 286;
- maxDist = 32;
- numCodes = 19; // number of codes in Huffman meta-code
+ maxCodeLen = 16 // max length of Huffman code
+ maxHist = 32768 // max history required
+ maxLit = 286
+ maxDist = 32
+ numCodes = 19 // number of codes in Huffman meta-code
)
// A CorruptInputError reports the presence of corrupt input at a given offset.
@@ -32,12 +32,12 @@ func (e CorruptInputError) String() string {
// An InternalError reports an error in the flate code itself.
type InternalError string
-func (e InternalError) String() string { return "flate: internal error: " + string(e) }
+func (e InternalError) String() string { return "flate: internal error: " + string(e) }
// A ReadError reports an error encountered while reading input.
type ReadError struct {
- Offset int64; // byte offset where error occurred
- Error os.Error; // error returned by underlying Read
+ Offset int64 // byte offset where error occurred
+ Error os.Error // error returned by underlying Read
}
func (e *ReadError) String() string {
@@ -46,8 +46,8 @@ func (e *ReadError) String() string {
// A WriteError reports an error encountered while writing output.
type WriteError struct {
- Offset int64; // byte offset where error occurred
- Error os.Error; // error returned by underlying Read
+ Offset int64 // byte offset where error occurred
+ Error os.Error // error returned by underlying Read
}
func (e *WriteError) String() string {
@@ -59,20 +59,20 @@ func (e *WriteError) String() string {
// Proceedings of the IEEE, 61(7) (July 1973), pp 1046-1047.
type huffmanDecoder struct {
// min, max code length
- min, max int;
+ min, max int
// limit[i] = largest code word of length i
// Given code v of length n,
// need more bits if v > limit[n].
- limit [maxCodeLen + 1]int;
+ limit [maxCodeLen + 1]int
// base[i] = smallest code word of length i - seq number
- base [maxCodeLen + 1]int;
+ base [maxCodeLen + 1]int
// codes[seq number] = output code.
// Given code v of length n, value is
// codes[v - base[n]].
- codes []int;
+ codes []int
}
// Initialize Huffman decoding tables from array of code lengths.
@@ -81,8 +81,8 @@ func (h *huffmanDecoder) init(bits []int) bool {
// Count number of codes of each length,
// compute min and max length.
- var count [maxCodeLen + 1]int;
- var min, max int;
+ var count [maxCodeLen + 1]int
+ var min, max int
for _, n := range bits {
if n == 0 {
continue
@@ -93,31 +93,31 @@ func (h *huffmanDecoder) init(bits []int) bool {
if n > max {
max = n
}
- count[n]++;
+ count[n]++
}
if max == 0 {
return false
}
- h.min = min;
- h.max = max;
+ h.min = min
+ h.max = max
// For each code range, compute
// nextcode (first code of that length),
// limit (last code of that length), and
// base (offset from first code to sequence number).
- code := 0;
- seq := 0;
- var nextcode [maxCodeLen]int;
+ code := 0
+ seq := 0
+ var nextcode [maxCodeLen]int
for i := min; i <= max; i++ {
- n := count[i];
- nextcode[i] = code;
- h.base[i] = code - seq;
- code += n;
- seq += n;
- h.limit[i] = code - 1;
- code <<= 1;
+ n := count[i]
+ nextcode[i] = code
+ h.base[i] = code - seq
+ code += n
+ seq += n
+ h.limit[i] = code - 1
+ code <<= 1
}
// Make array mapping sequence numbers to codes.
@@ -128,12 +128,12 @@ func (h *huffmanDecoder) init(bits []int) bool {
if n == 0 {
continue
}
- code := nextcode[n];
- nextcode[n]++;
- seq := code - h.base[n];
- h.codes[seq] = i;
+ code := nextcode[n]
+ nextcode[n]++
+ seq := code - h.base[n]
+ h.codes[seq] = i
}
- return true;
+ return true
}
// Hard-coded Huffman tables for DEFLATE algorithm.
@@ -192,51 +192,51 @@ var fixedHuffmanDecoder = huffmanDecoder{
// If the passed in io.Reader does not also have ReadByte,
// the NewInflater will introduce its own buffering.
type Reader interface {
- io.Reader;
- ReadByte() (c byte, err os.Error);
+ io.Reader
+ ReadByte() (c byte, err os.Error)
}
// Inflate state.
type inflater struct {
// Input/output sources.
- r Reader;
- w io.Writer;
- roffset int64;
- woffset int64;
+ r Reader
+ w io.Writer
+ roffset int64
+ woffset int64
// Input bits, in top of b.
- b uint32;
- nb uint;
+ b uint32
+ nb uint
// Huffman decoders for literal/length, distance.
- h1, h2 huffmanDecoder;
+ h1, h2 huffmanDecoder
// Length arrays used to define Huffman codes.
- bits [maxLit + maxDist]int;
- codebits [numCodes]int;
+ bits [maxLit + maxDist]int
+ codebits [numCodes]int
// Output history, buffer.
- hist [maxHist]byte;
- hp int; // current output position in buffer
- hfull bool; // buffer has filled at least once
+ hist [maxHist]byte
+ hp int // current output position in buffer
+ hfull bool // buffer has filled at least once
// Temporary buffer (avoids repeated allocation).
- buf [4]byte;
+ buf [4]byte
}
func (f *inflater) inflate() (err os.Error) {
- final := false;
+ final := false
for err == nil && !final {
for f.nb < 1+2 {
if err = f.moreBits(); err != nil {
return
}
}
- final = f.b&1 == 1;
- f.b >>= 1;
- typ := f.b & 3;
- f.b >>= 2;
- f.nb -= 1 + 2;
+ final = f.b&1 == 1
+ f.b >>= 1
+ typ := f.b & 3
+ f.b >>= 2
+ f.nb -= 1 + 2
switch typ {
case 0:
err = f.dataBlock()
@@ -253,7 +253,7 @@ func (f *inflater) inflate() (err os.Error) {
err = CorruptInputError(f.roffset)
}
}
- return;
+ return
}
// RFC 1951 section 3.2.7.
@@ -268,13 +268,13 @@ func (f *inflater) readHuffman() os.Error {
return err
}
}
- nlit := int(f.b&0x1F) + 257;
- f.b >>= 5;
- ndist := int(f.b&0x1F) + 1;
- f.b >>= 5;
- nclen := int(f.b&0xF) + 4;
- f.b >>= 4;
- f.nb -= 5 + 5 + 4;
+ nlit := int(f.b&0x1F) + 257
+ f.b >>= 5
+ ndist := int(f.b&0x1F) + 1
+ f.b >>= 5
+ nclen := int(f.b&0xF) + 4
+ f.b >>= 4
+ f.nb -= 5 + 5 + 4
// (HCLEN+4)*3 bits: code lengths in the magic codeOrder order.
for i := 0; i < nclen; i++ {
@@ -283,9 +283,9 @@ func (f *inflater) readHuffman() os.Error {
return err
}
}
- f.codebits[codeOrder[i]] = int(f.b & 0x7);
- f.b >>= 3;
- f.nb -= 3;
+ f.codebits[codeOrder[i]] = int(f.b & 0x7)
+ f.b >>= 3
+ f.nb -= 3
}
for i := nclen; i < len(codeOrder); i++ {
f.codebits[codeOrder[i]] = 0
@@ -297,53 +297,53 @@ func (f *inflater) readHuffman() os.Error {
// HLIT + 257 code lengths, HDIST + 1 code lengths,
// using the code length Huffman code.
for i, n := 0, nlit+ndist; i < n; {
- x, err := f.huffSym(&f.h1);
+ x, err := f.huffSym(&f.h1)
if err != nil {
return err
}
if x < 16 {
// Actual length.
- f.bits[i] = x;
- i++;
- continue;
+ f.bits[i] = x
+ i++
+ continue
}
// Repeat previous length or zero.
- var rep int;
- var nb uint;
- var b int;
+ var rep int
+ var nb uint
+ var b int
switch x {
default:
return InternalError("unexpected length code")
case 16:
- rep = 3;
- nb = 2;
+ rep = 3
+ nb = 2
if i == 0 {
return CorruptInputError(f.roffset)
}
- b = f.bits[i-1];
+ b = f.bits[i-1]
case 17:
- rep = 3;
- nb = 3;
- b = 0;
+ rep = 3
+ nb = 3
+ b = 0
case 18:
- rep = 11;
- nb = 7;
- b = 0;
+ rep = 11
+ nb = 7
+ b = 0
}
for f.nb < nb {
if err := f.moreBits(); err != nil {
return err
}
}
- rep += int(f.b & uint32(1<<nb-1));
- f.b >>= nb;
- f.nb -= nb;
+ rep += int(f.b & uint32(1<<nb-1))
+ f.b >>= nb
+ f.nb -= nb
if i+rep > n {
return CorruptInputError(f.roffset)
}
for j := 0; j < rep; j++ {
- f.bits[i] = b;
- i++;
+ f.bits[i] = b
+ i++
}
}
@@ -351,7 +351,7 @@ func (f *inflater) readHuffman() os.Error {
return CorruptInputError(f.roffset)
}
- return nil;
+ return nil
}
// Decode a single Huffman block from f.
@@ -360,46 +360,46 @@ func (f *inflater) readHuffman() os.Error {
// fixed distance encoding associated with fixed Huffman blocks.
func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
for {
- v, err := f.huffSym(hl);
+ v, err := f.huffSym(hl)
if err != nil {
return err
}
- var n uint; // number of bits extra
- var length int;
+ var n uint // number of bits extra
+ var length int
switch {
case v < 256:
- f.hist[f.hp] = byte(v);
- f.hp++;
+ f.hist[f.hp] = byte(v)
+ f.hp++
if f.hp == len(f.hist) {
if err = f.flush(); err != nil {
return err
}
}
- continue;
+ continue
case v == 256:
return nil
// otherwise, reference to older data
case v < 265:
- length = v - (257 - 3);
- n = 0;
+ length = v - (257 - 3)
+ n = 0
case v < 269:
- length = v*2 - (265*2 - 11);
- n = 1;
+ length = v*2 - (265*2 - 11)
+ n = 1
case v < 273:
- length = v*4 - (269*4 - 19);
- n = 2;
+ length = v*4 - (269*4 - 19)
+ n = 2
case v < 277:
- length = v*8 - (273*8 - 35);
- n = 3;
+ length = v*8 - (273*8 - 35)
+ n = 3
case v < 281:
- length = v*16 - (277*16 - 67);
- n = 4;
+ length = v*16 - (277*16 - 67)
+ n = 4
case v < 285:
- length = v*32 - (281*32 - 131);
- n = 5;
+ length = v*32 - (281*32 - 131)
+ n = 5
default:
- length = 258;
- n = 0;
+ length = 258
+ n = 0
}
if n > 0 {
for f.nb < n {
@@ -407,21 +407,21 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
return err
}
}
- length += int(f.b & uint32(1<<n-1));
- f.b >>= n;
- f.nb -= n;
+ length += int(f.b & uint32(1<<n-1))
+ f.b >>= n
+ f.nb -= n
}
- var dist int;
+ var dist int
if hd == nil {
for f.nb < 5 {
if err = f.moreBits(); err != nil {
return err
}
}
- dist = int(reverseByte[(f.b&0x1F)<<3]);
- f.b >>= 5;
- f.nb -= 5;
+ dist = int(reverseByte[(f.b&0x1F)<<3])
+ f.b >>= 5
+ f.nb -= 5
} else {
if dist, err = f.huffSym(hd); err != nil {
return err
@@ -434,18 +434,18 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
case dist >= 30:
return CorruptInputError(f.roffset)
default:
- nb := uint(dist-2) >> 1;
+ nb := uint(dist-2) >> 1
// have 1 bit in bottom of dist, need nb more.
- extra := (dist & 1) << nb;
+ extra := (dist & 1) << nb
for f.nb < nb {
if err = f.moreBits(); err != nil {
return err
}
}
- extra |= int(f.b & uint32(1<<nb-1));
- f.b >>= nb;
- f.nb -= nb;
- dist = 1<<(nb+1) + 1 + extra;
+ extra |= int(f.b & uint32(1<<nb-1))
+ f.b >>= nb
+ f.nb -= nb
+ dist = 1<<(nb+1) + 1 + extra
}
// Copy history[-dist:-dist+length] into output.
@@ -458,14 +458,14 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
return CorruptInputError(f.roffset)
}
- p := f.hp - dist;
+ p := f.hp - dist
if p < 0 {
p += len(f.hist)
}
for i := 0; i < length; i++ {
- f.hist[f.hp] = f.hist[p];
- f.hp++;
- p++;
+ f.hist[f.hp] = f.hist[p]
+ f.hp++
+ p++
if f.hp == len(f.hist) {
if err = f.flush(); err != nil {
return err
@@ -476,24 +476,24 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
}
}
}
- panic("unreached");
+ panic("unreached")
}
// Copy a single uncompressed data block from input to output.
func (f *inflater) dataBlock() os.Error {
// Uncompressed.
// Discard current half-byte.
- f.nb = 0;
- f.b = 0;
+ f.nb = 0
+ f.b = 0
// Length then ones-complement of length.
- nr, err := io.ReadFull(f.r, f.buf[0:4]);
- f.roffset += int64(nr);
+ nr, err := io.ReadFull(f.r, f.buf[0:4])
+ f.roffset += int64(nr)
if err != nil {
return &ReadError{f.roffset, err}
}
- n := int(f.buf[0]) | int(f.buf[1])<<8;
- nn := int(f.buf[2]) | int(f.buf[3])<<8;
+ n := int(f.buf[0]) | int(f.buf[1])<<8
+ nn := int(f.buf[2]) | int(f.buf[3])<<8
if uint16(nn) != uint16(^n) {
return CorruptInputError(f.roffset)
}
@@ -501,44 +501,44 @@ func (f *inflater) dataBlock() os.Error {
// Read len bytes into history,
// writing as history fills.
for n > 0 {
- m := len(f.hist) - f.hp;
+ m := len(f.hist) - f.hp
if m > n {
m = n
}
- m, err := io.ReadFull(f.r, f.hist[f.hp:f.hp+m]);
- f.roffset += int64(m);
+ m, err := io.ReadFull(f.r, f.hist[f.hp:f.hp+m])
+ f.roffset += int64(m)
if err != nil {
return &ReadError{f.roffset, err}
}
- n -= m;
- f.hp += m;
+ n -= m
+ f.hp += m
if f.hp == len(f.hist) {
if err = f.flush(); err != nil {
return err
}
}
}
- return nil;
+ return nil
}
func (f *inflater) moreBits() os.Error {
- c, err := f.r.ReadByte();
+ c, err := f.r.ReadByte()
if err != nil {
if err == os.EOF {
err = io.ErrUnexpectedEOF
}
- return err;
+ return err
}
- f.roffset++;
- f.b |= uint32(c) << f.nb;
- f.nb += 8;
- return nil;
+ f.roffset++
+ f.b |= uint32(c) << f.nb
+ f.nb += 8
+ return nil
}
// Read the next Huffman-encoded symbol from f according to h.
func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) {
for n := uint(h.min); n <= uint(h.max); n++ {
- lim := h.limit[n];
+ lim := h.limit[n]
if lim == -1 {
continue
}
@@ -547,16 +547,16 @@ func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) {
return 0, err
}
}
- v := int(f.b & uint32(1<<n-1));
- v <<= 16 - n;
- v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8; // reverse bits
+ v := int(f.b & uint32(1<<n-1))
+ v <<= 16 - n
+ v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8 // reverse bits
if v <= lim {
- f.b >>= n;
- f.nb -= n;
- return h.codes[v-h.base[n]], nil;
+ f.b >>= n
+ f.nb -= n
+ return h.codes[v-h.base[n]], nil
}
}
- return 0, CorruptInputError(f.roffset);
+ return 0, CorruptInputError(f.roffset)
}
// Flush any buffered output to the underlying writer.
@@ -564,39 +564,39 @@ func (f *inflater) flush() os.Error {
if f.hp == 0 {
return nil
}
- n, err := f.w.Write(f.hist[0:f.hp]);
+ n, err := f.w.Write(f.hist[0:f.hp])
if n != f.hp && err == nil {
err = io.ErrShortWrite
}
if err != nil {
return &WriteError{f.woffset, err}
}
- f.woffset += int64(f.hp);
- f.hp = 0;
- f.hfull = true;
- return nil;
+ f.woffset += int64(f.hp)
+ f.hp = 0
+ f.hfull = true
+ return nil
}
func makeReader(r io.Reader) Reader {
if rr, ok := r.(Reader); ok {
return rr
}
- return bufio.NewReader(r);
+ return bufio.NewReader(r)
}
// Inflate reads DEFLATE-compressed data from r and writes
// the uncompressed data to w.
func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error {
- f.r = makeReader(r);
- f.w = w;
- f.woffset = 0;
+ f.r = makeReader(r)
+ f.w = w
+ f.woffset = 0
if err := f.inflate(); err != nil {
return err
}
if err := f.flush(); err != nil {
return err
}
- return nil;
+ return nil
}
// NewInflater returns a new ReadCloser that can be used
@@ -604,8 +604,8 @@ func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error {
// responsibility to call Close on the ReadCloser when
// finished reading.
func NewInflater(r io.Reader) io.ReadCloser {
- var f inflater;
- pr, pw := io.Pipe();
- go func() { pw.CloseWithError(f.inflater(r, pw)) }();
- return pr;
+ var f inflater
+ pr, pw := io.Pipe()
+ go func() { pw.CloseWithError(f.inflater(r, pw)) }()
+ return pr
}
diff --git a/src/pkg/compress/flate/token.go b/src/pkg/compress/flate/token.go
index 139e1d0da..38aea5fa6 100644
--- a/src/pkg/compress/flate/token.go
+++ b/src/pkg/compress/flate/token.go
@@ -8,11 +8,11 @@ const (
// 2 bits: type 0 = literal 1=EOF 2=Match 3=Unused
// 8 bits: xlength = length - MIN_MATCH_LENGTH
// 22 bits xoffset = offset - MIN_OFFSET_SIZE, or literal
- lengthShift = 22;
- offsetMask = 1<<lengthShift - 1;
- typeMask = 3 << 30;
- literalType = 0 << 30;
- matchType = 1 << 30;
+ lengthShift = 22
+ offsetMask = 1<<lengthShift - 1
+ typeMask = 3 << 30
+ literalType = 0 << 30
+ matchType = 1 << 30
)
// The length code for length X (MIN_MATCH_LENGTH <= X <= MAX_MATCH_LENGTH)
@@ -68,7 +68,7 @@ var offsetCodes = [...]uint32{
type token uint32
// Convert a literal into a literal token.
-func literalToken(literal uint32) token { return token(literalType + literal) }
+func literalToken(literal uint32) token { return token(literalType + literal) }
// Convert a < xlength, xoffset > pair into a match token.
func matchToken(xlength uint32, xoffset uint32) token {
@@ -76,21 +76,21 @@ func matchToken(xlength uint32, xoffset uint32) token {
}
// Returns the type of a token
-func (t token) typ() uint32 { return uint32(t) & typeMask }
+func (t token) typ() uint32 { return uint32(t) & typeMask }
// Returns the literal of a literal token
-func (t token) literal() uint32 { return uint32(t - literalType) }
+func (t token) literal() uint32 { return uint32(t - literalType) }
// Returns the extra offset of a match token
-func (t token) offset() uint32 { return uint32(t) & offsetMask }
+func (t token) offset() uint32 { return uint32(t) & offsetMask }
-func (t token) length() uint32 { return uint32((t - matchType) >> lengthShift) }
+func (t token) length() uint32 { return uint32((t - matchType) >> lengthShift) }
-func lengthCode(len uint32) uint32 { return lengthCodes[len] }
+func lengthCode(len uint32) uint32 { return lengthCodes[len] }
// Returns the offset code corresponding to a specific offset
func offsetCode(off uint32) uint32 {
- const n = uint32(len(offsetCodes));
+ const n = uint32(len(offsetCodes))
switch {
case off < n:
return offsetCodes[off]
@@ -99,5 +99,5 @@ func offsetCode(off uint32) uint32 {
default:
return offsetCodes[off>>14] + 28
}
- panic("unreachable");
+ panic("unreachable")
}
diff --git a/src/pkg/compress/flate/util.go b/src/pkg/compress/flate/util.go
index f4e0b9ba3..aca5c78b2 100644
--- a/src/pkg/compress/flate/util.go
+++ b/src/pkg/compress/flate/util.go
@@ -8,21 +8,21 @@ func min(left int, right int) int {
if left < right {
return left
}
- return right;
+ return right
}
func minInt32(left int32, right int32) int32 {
if left < right {
return left
}
- return right;
+ return right
}
func max(left int, right int) int {
if left > right {
return left
}
- return right;
+ return right
}
func fillInts(a []int, value int) {
@@ -56,17 +56,17 @@ func fillUint8s(a []uint8, value uint8) {
}
func copyInt8s(dst []int8, src []int8) int {
- cnt := min(len(dst), len(src));
+ cnt := min(len(dst), len(src))
for i := 0; i < cnt; i++ {
dst[i] = src[i]
}
- return cnt;
+ return cnt
}
func copyUint8s(dst []uint8, src []uint8) int {
- cnt := min(len(dst), len(src));
+ cnt := min(len(dst), len(src))
for i := 0; i < cnt; i++ {
dst[i] = src[i]
}
- return cnt;
+ return cnt
}
diff --git a/src/pkg/compress/gzip/gunzip.go b/src/pkg/compress/gzip/gunzip.go
index ef84f16fc..b2a08830c 100644
--- a/src/pkg/compress/gzip/gunzip.go
+++ b/src/pkg/compress/gzip/gunzip.go
@@ -7,30 +7,30 @@
package gzip
import (
- "bufio";
- "compress/flate";
- "hash";
- "hash/crc32";
- "io";
- "os";
+ "bufio"
+ "compress/flate"
+ "hash"
+ "hash/crc32"
+ "io"
+ "os"
)
const (
- gzipID1 = 0x1f;
- gzipID2 = 0x8b;
- gzipDeflate = 8;
- flagText = 1 << 0;
- flagHdrCrc = 1 << 1;
- flagExtra = 1 << 2;
- flagName = 1 << 3;
- flagComment = 1 << 4;
+ gzipID1 = 0x1f
+ gzipID2 = 0x8b
+ gzipDeflate = 8
+ flagText = 1 << 0
+ flagHdrCrc = 1 << 1
+ flagExtra = 1 << 2
+ flagName = 1 << 3
+ flagComment = 1 << 4
)
func makeReader(r io.Reader) flate.Reader {
if rr, ok := r.(flate.Reader); ok {
return rr
}
- return bufio.NewReader(r);
+ return bufio.NewReader(r)
}
var HeaderError os.Error = os.ErrorString("invalid gzip header")
@@ -53,34 +53,34 @@ var ChecksumError os.Error = os.ErrorString("gzip checksum error")
// returned by Read as tentative until they receive the successful
// (zero length, nil error) Read marking the end of the data.
type Inflater struct {
- Comment string; // comment
- Extra []byte; // "extra data"
- Mtime uint32; // modification time (seconds since January 1, 1970)
- Name string; // file name
- OS byte; // operating system type
-
- r flate.Reader;
- inflater io.ReadCloser;
- digest hash.Hash32;
- size uint32;
- flg byte;
- buf [512]byte;
- err os.Error;
- eof bool;
+ Comment string // comment
+ Extra []byte // "extra data"
+ Mtime uint32 // modification time (seconds since January 1, 1970)
+ Name string // file name
+ OS byte // operating system type
+
+ r flate.Reader
+ inflater io.ReadCloser
+ digest hash.Hash32
+ size uint32
+ flg byte
+ buf [512]byte
+ err os.Error
+ eof bool
}
// NewInflater creates a new Inflater reading the given reader.
// The implementation buffers input and may read more data than necessary from r.
// It is the caller's responsibility to call Close on the Inflater when done.
func NewInflater(r io.Reader) (*Inflater, os.Error) {
- z := new(Inflater);
- z.r = makeReader(r);
- z.digest = crc32.NewIEEE();
+ z := new(Inflater)
+ z.r = makeReader(r)
+ z.digest = crc32.NewIEEE()
if err := z.readHeader(true); err != nil {
- z.err = err;
- return nil, err;
+ z.err = err
+ return nil, err
}
- return z, nil;
+ return z, nil
}
// GZIP (RFC 1952) is little-endian, unlike ZLIB (RFC 1950).
@@ -89,12 +89,12 @@ func get4(p []byte) uint32 {
}
func (z *Inflater) readString() (string, os.Error) {
- var err os.Error;
+ var err os.Error
for i := 0; ; i++ {
if i >= len(z.buf) {
return "", HeaderError
}
- z.buf[i], err = z.r.ReadByte();
+ z.buf[i], err = z.r.ReadByte()
if err != nil {
return "", err
}
@@ -102,40 +102,40 @@ func (z *Inflater) readString() (string, os.Error) {
return string(z.buf[0:i]), nil
}
}
- panic("not reached");
+ panic("not reached")
}
func (z *Inflater) read2() (uint32, os.Error) {
- _, err := z.r.Read(z.buf[0:2]);
+ _, err := z.r.Read(z.buf[0:2])
if err != nil {
return 0, err
}
- return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil;
+ return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil
}
func (z *Inflater) readHeader(save bool) os.Error {
- _, err := io.ReadFull(z.r, z.buf[0:10]);
+ _, err := io.ReadFull(z.r, z.buf[0:10])
if err != nil {
return err
}
if z.buf[0] != gzipID1 || z.buf[1] != gzipID2 || z.buf[2] != gzipDeflate {
return HeaderError
}
- z.flg = z.buf[3];
+ z.flg = z.buf[3]
if save {
- z.Mtime = get4(z.buf[4:8]);
+ z.Mtime = get4(z.buf[4:8])
// z.buf[8] is xfl, ignored
- z.OS = z.buf[9];
+ z.OS = z.buf[9]
}
- z.digest.Reset();
- z.digest.Write(z.buf[0:10]);
+ z.digest.Reset()
+ z.digest.Write(z.buf[0:10])
if z.flg&flagExtra != 0 {
- n, err := z.read2();
+ n, err := z.read2()
if err != nil {
return err
}
- data := make([]byte, n);
+ data := make([]byte, n)
if _, err = io.ReadFull(z.r, data); err != nil {
return err
}
@@ -144,7 +144,7 @@ func (z *Inflater) readHeader(save bool) os.Error {
}
}
- var s string;
+ var s string
if z.flg&flagName != 0 {
if s, err = z.readString(); err != nil {
return err
@@ -164,19 +164,19 @@ func (z *Inflater) readHeader(save bool) os.Error {
}
if z.flg&flagHdrCrc != 0 {
- n, err := z.read2();
+ n, err := z.read2()
if err != nil {
return err
}
- sum := z.digest.Sum32() & 0xFFFF;
+ sum := z.digest.Sum32() & 0xFFFF
if n != sum {
return HeaderError
}
}
- z.digest.Reset();
- z.inflater = flate.NewInflater(z.r);
- return nil;
+ z.digest.Reset()
+ z.inflater = flate.NewInflater(z.r)
+ return nil
}
func (z *Inflater) Read(p []byte) (n int, err os.Error) {
@@ -187,37 +187,37 @@ func (z *Inflater) Read(p []byte) (n int, err os.Error) {
return 0, nil
}
- n, err = z.inflater.Read(p);
- z.digest.Write(p[0:n]);
- z.size += uint32(n);
+ n, err = z.inflater.Read(p)
+ z.digest.Write(p[0:n])
+ z.size += uint32(n)
if n != 0 || err != os.EOF {
- z.err = err;
- return;
+ z.err = err
+ return
}
// Finished file; check checksum + size.
if _, err := io.ReadFull(z.r, z.buf[0:8]); err != nil {
- z.err = err;
- return 0, err;
+ z.err = err
+ return 0, err
}
- crc32, isize := get4(z.buf[0:4]), get4(z.buf[4:8]);
- sum := z.digest.Sum32();
+ crc32, isize := get4(z.buf[0:4]), get4(z.buf[4:8])
+ sum := z.digest.Sum32()
if sum != crc32 || isize != z.size {
- z.err = ChecksumError;
- return 0, z.err;
+ z.err = ChecksumError
+ return 0, z.err
}
// File is ok; is there another?
if err = z.readHeader(false); err != nil {
- z.err = err;
- return;
+ z.err = err
+ return
}
// Yes. Reset and read from it.
- z.digest.Reset();
- z.size = 0;
- return z.Read(p);
+ z.digest.Reset()
+ z.size = 0
+ return z.Read(p)
}
// Calling Close does not close the wrapped io.Reader originally passed to NewInflater.
-func (z *Inflater) Close() os.Error { return z.inflater.Close() }
+func (z *Inflater) Close() os.Error { return z.inflater.Close() }
diff --git a/src/pkg/compress/gzip/gunzip_test.go b/src/pkg/compress/gzip/gunzip_test.go
index 67b3b3ce2..3930985e3 100644
--- a/src/pkg/compress/gzip/gunzip_test.go
+++ b/src/pkg/compress/gzip/gunzip_test.go
@@ -5,22 +5,22 @@
package gzip
import (
- "bytes";
- "io";
- "os";
- "testing";
+ "bytes"
+ "io"
+ "os"
+ "testing"
)
type gzipTest struct {
- name string;
- desc string;
- raw string;
- gzip []byte;
- err os.Error;
+ name string
+ desc string
+ raw string
+ gzip []byte
+ err os.Error
}
var gzipTests = []gzipTest{
- gzipTest{ // has 1 empty fixed-huffman block
+ gzipTest{ // has 1 empty fixed-huffman block
"empty.txt",
"empty.txt",
"",
@@ -32,7 +32,7 @@ var gzipTests = []gzipTest{
},
nil,
},
- gzipTest{ // has 1 non-empty fixed huffman block
+ gzipTest{ // has 1 non-empty fixed huffman block
"hello.txt",
"hello.txt",
"hello world\n",
@@ -46,7 +46,7 @@ var gzipTests = []gzipTest{
},
nil,
},
- gzipTest{ // concatenation
+ gzipTest{ // concatenation
"hello.txt",
"hello.txt x2",
"hello world\n" +
@@ -67,7 +67,7 @@ var gzipTests = []gzipTest{
},
nil,
},
- gzipTest{ // has a fixed huffman block with some length-distance pairs
+ gzipTest{ // has a fixed huffman block with some length-distance pairs
"shesells.txt",
"shesells.txt",
"she sells seashells by the seashore\n",
@@ -83,7 +83,7 @@ var gzipTests = []gzipTest{
},
nil,
},
- gzipTest{ // has dynamic huffman blocks
+ gzipTest{ // has dynamic huffman blocks
"gettysburg",
"gettysburg",
" Four score and seven years ago our fathers brought forth on\n" +
@@ -221,7 +221,7 @@ var gzipTests = []gzipTest{
},
nil,
},
- gzipTest{ // has 1 non-empty fixed huffman block then garbage
+ gzipTest{ // has 1 non-empty fixed huffman block then garbage
"hello.txt",
"hello.txt + garbage",
"hello world\n",
@@ -235,7 +235,7 @@ var gzipTests = []gzipTest{
},
HeaderError,
},
- gzipTest{ // has 1 non-empty fixed huffman block not enough header
+ gzipTest{ // has 1 non-empty fixed huffman block not enough header
"hello.txt",
"hello.txt + garbage",
"hello world\n",
@@ -249,7 +249,7 @@ var gzipTests = []gzipTest{
},
io.ErrUnexpectedEOF,
},
- gzipTest{ // has 1 non-empty fixed huffman block but corrupt checksum
+ gzipTest{ // has 1 non-empty fixed huffman block but corrupt checksum
"hello.txt",
"hello.txt + corrupt checksum",
"hello world\n",
@@ -263,7 +263,7 @@ var gzipTests = []gzipTest{
},
ChecksumError,
},
- gzipTest{ // has 1 non-empty fixed huffman block but corrupt size
+ gzipTest{ // has 1 non-empty fixed huffman block but corrupt size
"hello.txt",
"hello.txt + corrupt size",
"hello world\n",
@@ -280,24 +280,24 @@ var gzipTests = []gzipTest{
}
func TestInflater(t *testing.T) {
- b := new(bytes.Buffer);
+ b := new(bytes.Buffer)
for _, tt := range gzipTests {
- in := bytes.NewBuffer(tt.gzip);
- gzip, err := NewInflater(in);
+ in := bytes.NewBuffer(tt.gzip)
+ gzip, err := NewInflater(in)
if err != nil {
- t.Errorf("%s: NewInflater: %s", tt.name, err);
- continue;
+ t.Errorf("%s: NewInflater: %s", tt.name, err)
+ continue
}
- defer gzip.Close();
+ defer gzip.Close()
if tt.name != gzip.Name {
t.Errorf("%s: got name %s", tt.name, gzip.Name)
}
- b.Reset();
- n, err := io.Copy(b, gzip);
+ b.Reset()
+ n, err := io.Copy(b, gzip)
if err != tt.err {
t.Errorf("%s: io.Copy: %v want %v", tt.name, err, tt.err)
}
- s := b.String();
+ s := b.String()
if s != tt.raw {
t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.name, n, s, len(tt.raw), tt.raw)
}
diff --git a/src/pkg/compress/zlib/reader.go b/src/pkg/compress/zlib/reader.go
index ffe5cbafc..c3a9d28ca 100644
--- a/src/pkg/compress/zlib/reader.go
+++ b/src/pkg/compress/zlib/reader.go
@@ -7,12 +7,12 @@
package zlib
import (
- "bufio";
- "compress/flate";
- "hash";
- "hash/adler32";
- "io";
- "os";
+ "bufio"
+ "compress/flate"
+ "hash"
+ "hash/adler32"
+ "io"
+ "os"
)
const zlibDeflate = 8
@@ -22,28 +22,28 @@ var HeaderError os.Error = os.ErrorString("invalid zlib header")
var UnsupportedError os.Error = os.ErrorString("unsupported zlib format")
type reader struct {
- r flate.Reader;
- inflater io.ReadCloser;
- digest hash.Hash32;
- err os.Error;
- scratch [4]byte;
+ r flate.Reader
+ inflater io.ReadCloser
+ digest hash.Hash32
+ err os.Error
+ scratch [4]byte
}
// NewInflater creates a new io.ReadCloser that satisfies reads by decompressing data read from r.
// The implementation buffers input and may read more data than necessary from r.
// It is the caller's responsibility to call Close on the ReadCloser when done.
func NewInflater(r io.Reader) (io.ReadCloser, os.Error) {
- z := new(reader);
+ z := new(reader)
if fr, ok := r.(flate.Reader); ok {
z.r = fr
} else {
z.r = bufio.NewReader(r)
}
- _, err := io.ReadFull(z.r, z.scratch[0:2]);
+ _, err := io.ReadFull(z.r, z.scratch[0:2])
if err != nil {
return nil, err
}
- h := uint(z.scratch[0])<<8 | uint(z.scratch[1]);
+ h := uint(z.scratch[0])<<8 | uint(z.scratch[1])
if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) {
return nil, HeaderError
}
@@ -51,9 +51,9 @@ func NewInflater(r io.Reader) (io.ReadCloser, os.Error) {
// BUG(nigeltao): The zlib package does not implement the FDICT flag.
return nil, UnsupportedError
}
- z.digest = adler32.New();
- z.inflater = flate.NewInflater(z.r);
- return z, nil;
+ z.digest = adler32.New()
+ z.inflater = flate.NewInflater(z.r)
+ return z, nil
}
func (z *reader) Read(p []byte) (n int, err os.Error) {
@@ -64,25 +64,25 @@ func (z *reader) Read(p []byte) (n int, err os.Error) {
return 0, nil
}
- n, err = z.inflater.Read(p);
- z.digest.Write(p[0:n]);
+ n, err = z.inflater.Read(p)
+ z.digest.Write(p[0:n])
if n != 0 || err != os.EOF {
- z.err = err;
- return;
+ z.err = err
+ return
}
// Finished file; check checksum.
if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil {
- z.err = err;
- return 0, err;
+ z.err = err
+ return 0, err
}
// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
- checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]);
+ checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3])
if checksum != z.digest.Sum32() {
- z.err = ChecksumError;
- return 0, z.err;
+ z.err = ChecksumError
+ return 0, z.err
}
- return;
+ return
}
// Calling Close does not close the wrapped io.Reader originally passed to NewInflater.
@@ -90,6 +90,6 @@ func (z *reader) Close() os.Error {
if z.err != nil {
return z.err
}
- z.err = z.inflater.Close();
- return z.err;
+ z.err = z.inflater.Close()
+ return z.err
}
diff --git a/src/pkg/compress/zlib/reader_test.go b/src/pkg/compress/zlib/reader_test.go
index 5e057ee21..3b349f5ee 100644
--- a/src/pkg/compress/zlib/reader_test.go
+++ b/src/pkg/compress/zlib/reader_test.go
@@ -5,17 +5,17 @@
package zlib
import (
- "bytes";
- "io";
- "os";
- "testing";
+ "bytes"
+ "io"
+ "os"
+ "testing"
)
type zlibTest struct {
- desc string;
- raw string;
- compressed []byte;
- err os.Error;
+ desc string
+ raw string
+ compressed []byte
+ err os.Error
}
// Compare-to-golden test data was generated by the ZLIB example program at
@@ -68,26 +68,26 @@ var zlibTests = []zlibTest{
}
func TestInflater(t *testing.T) {
- b := new(bytes.Buffer);
+ b := new(bytes.Buffer)
for _, tt := range zlibTests {
- in := bytes.NewBuffer(tt.compressed);
- zlib, err := NewInflater(in);
+ in := bytes.NewBuffer(tt.compressed)
+ zlib, err := NewInflater(in)
if err != nil {
if err != tt.err {
t.Errorf("%s: NewInflater: %s", tt.desc, err)
}
- continue;
+ continue
}
- defer zlib.Close();
- b.Reset();
- n, err := io.Copy(b, zlib);
+ defer zlib.Close()
+ b.Reset()
+ n, err := io.Copy(b, zlib)
if err != nil {
if err != tt.err {
t.Errorf("%s: io.Copy: %v want %v", tt.desc, err, tt.err)
}
- continue;
+ continue
}
- s := b.String();
+ s := b.String()
if s != tt.raw {
t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.desc, n, s, len(tt.raw), tt.raw)
}
diff --git a/src/pkg/compress/zlib/writer.go b/src/pkg/compress/zlib/writer.go
index 25abcde3b..0441b0463 100644
--- a/src/pkg/compress/zlib/writer.go
+++ b/src/pkg/compress/zlib/writer.go
@@ -5,28 +5,28 @@
package zlib
import (
- "compress/flate";
- "hash";
- "hash/adler32";
- "io";
- "os";
+ "compress/flate"
+ "hash"
+ "hash/adler32"
+ "io"
+ "os"
)
// These constants are copied from the flate package, so that code that imports
// "compress/zlib" does not also have to import "compress/flate".
const (
- NoCompression = flate.NoCompression;
- BestSpeed = flate.BestSpeed;
- BestCompression = flate.BestCompression;
- DefaultCompression = flate.DefaultCompression;
+ NoCompression = flate.NoCompression
+ BestSpeed = flate.BestSpeed
+ BestCompression = flate.BestCompression
+ DefaultCompression = flate.DefaultCompression
)
type writer struct {
- w io.Writer;
- deflater io.WriteCloser;
- digest hash.Hash32;
- err os.Error;
- scratch [4]byte;
+ w io.Writer
+ deflater io.WriteCloser
+ digest hash.Hash32
+ err os.Error
+ scratch [4]byte
}
// NewDeflater calls NewDeflaterLevel with the default compression level.
@@ -39,11 +39,11 @@ func NewDeflater(w io.Writer) (io.WriteCloser, os.Error) {
// level is the compression level, which can be DefaultCompression, NoCompression,
// or any integer value between BestSpeed and BestCompression (inclusive).
func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
- z := new(writer);
+ z := new(writer)
// ZLIB has a two-byte header (as documented in RFC 1950).
// The first four bits is the CINFO (compression info), which is 7 for the default deflate window size.
// The next four bits is the CM (compression method), which is 8 for deflate.
- z.scratch[0] = 0x78;
+ z.scratch[0] = 0x78
// The next two bits is the FLEVEL (compression level). The four values are:
// 0=fastest, 1=fast, 2=default, 3=best.
// The next bit, FDICT, is unused, in this implementation.
@@ -60,14 +60,14 @@ func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
default:
return nil, os.NewError("level out of range")
}
- _, err := w.Write(z.scratch[0:2]);
+ _, err := w.Write(z.scratch[0:2])
if err != nil {
return nil, err
}
- z.w = w;
- z.deflater = flate.NewDeflater(w, level);
- z.digest = adler32.New();
- return z, nil;
+ z.w = w
+ z.deflater = flate.NewDeflater(w, level)
+ z.digest = adler32.New()
+ return z, nil
}
func (z *writer) Write(p []byte) (n int, err os.Error) {
@@ -77,13 +77,13 @@ func (z *writer) Write(p []byte) (n int, err os.Error) {
if len(p) == 0 {
return 0, nil
}
- n, err = z.deflater.Write(p);
+ n, err = z.deflater.Write(p)
if err != nil {
- z.err = err;
- return;
+ z.err = err
+ return
}
- z.digest.Write(p);
- return;
+ z.digest.Write(p)
+ return
}
// Calling Close does not close the wrapped io.Writer originally passed to NewDeflater.
@@ -91,16 +91,16 @@ func (z *writer) Close() os.Error {
if z.err != nil {
return z.err
}
- z.err = z.deflater.Close();
+ z.err = z.deflater.Close()
if z.err != nil {
return z.err
}
- checksum := z.digest.Sum32();
+ checksum := z.digest.Sum32()
// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
- z.scratch[0] = uint8(checksum >> 24);
- z.scratch[1] = uint8(checksum >> 16);
- z.scratch[2] = uint8(checksum >> 8);
- z.scratch[3] = uint8(checksum >> 0);
- _, z.err = z.w.Write(z.scratch[0:4]);
- return z.err;
+ z.scratch[0] = uint8(checksum >> 24)
+ z.scratch[1] = uint8(checksum >> 16)
+ z.scratch[2] = uint8(checksum >> 8)
+ z.scratch[3] = uint8(checksum >> 0)
+ _, z.err = z.w.Write(z.scratch[0:4])
+ return z.err
}
diff --git a/src/pkg/compress/zlib/writer_test.go b/src/pkg/compress/zlib/writer_test.go
index 963a072e9..97a9ed619 100644
--- a/src/pkg/compress/zlib/writer_test.go
+++ b/src/pkg/compress/zlib/writer_test.go
@@ -5,10 +5,10 @@
package zlib
import (
- "io";
- "io/ioutil";
- "os";
- "testing";
+ "io"
+ "io/ioutil"
+ "os"
+ "testing"
)
var filenames = []string{
@@ -20,85 +20,85 @@ var filenames = []string{
// yields equivalent bytes to the original file.
func testFileLevel(t *testing.T, fn string, level int) {
// Read the file, as golden output.
- golden, err := os.Open(fn, os.O_RDONLY, 0444);
+ golden, err := os.Open(fn, os.O_RDONLY, 0444)
if err != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err)
+ return
}
- defer golden.Close();
+ defer golden.Close()
// Read the file again, and push it through a pipe that compresses at the write end, and decompresses at the read end.
- raw, err := os.Open(fn, os.O_RDONLY, 0444);
+ raw, err := os.Open(fn, os.O_RDONLY, 0444)
if err != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err)
+ return
}
- piper, pipew := io.Pipe();
- defer piper.Close();
+ piper, pipew := io.Pipe()
+ defer piper.Close()
go func() {
- defer raw.Close();
- defer pipew.Close();
- zlibw, err := NewDeflaterLevel(pipew, level);
+ defer raw.Close()
+ defer pipew.Close()
+ zlibw, err := NewDeflaterLevel(pipew, level)
if err != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err)
+ return
}
- defer zlibw.Close();
- var b [1024]byte;
+ defer zlibw.Close()
+ var b [1024]byte
for {
- n, err0 := raw.Read(&b);
+ n, err0 := raw.Read(&b)
if err0 != nil && err0 != os.EOF {
- t.Errorf("%s (level=%d): %v", fn, level, err0);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err0)
+ return
}
- _, err1 := zlibw.Write(b[0:n]);
+ _, err1 := zlibw.Write(b[0:n])
if err1 == os.EPIPE {
// Fail, but do not report the error, as some other (presumably reportable) error broke the pipe.
return
}
if err1 != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err1);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err1)
+ return
}
if err0 == os.EOF {
break
}
}
- }();
- zlibr, err := NewInflater(piper);
+ }()
+ zlibr, err := NewInflater(piper)
if err != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err)
+ return
}
- defer zlibr.Close();
+ defer zlibr.Close()
// Compare the two.
- b0, err0 := ioutil.ReadAll(golden);
- b1, err1 := ioutil.ReadAll(zlibr);
+ b0, err0 := ioutil.ReadAll(golden)
+ b1, err1 := ioutil.ReadAll(zlibr)
if err0 != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err0);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err0)
+ return
}
if err1 != nil {
- t.Errorf("%s (level=%d): %v", fn, level, err1);
- return;
+ t.Errorf("%s (level=%d): %v", fn, level, err1)
+ return
}
if len(b0) != len(b1) {
- t.Errorf("%s (level=%d): length mismatch %d versus %d", fn, level, len(b0), len(b1));
- return;
+ t.Errorf("%s (level=%d): length mismatch %d versus %d", fn, level, len(b0), len(b1))
+ return
}
for i := 0; i < len(b0); i++ {
if b0[i] != b1[i] {
- t.Errorf("%s (level=%d): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, i, b0[i], b1[i]);
- return;
+ t.Errorf("%s (level=%d): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, i, b0[i], b1[i])
+ return
}
}
}
func TestWriter(t *testing.T) {
for _, fn := range filenames {
- testFileLevel(t, fn, DefaultCompression);
- testFileLevel(t, fn, NoCompression);
+ testFileLevel(t, fn, DefaultCompression)
+ testFileLevel(t, fn, NoCompression)
for level := BestSpeed; level <= BestCompression; level++ {
testFileLevel(t, fn, level)
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-28 09:46:50 +0000