summaryrefslogtreecommitdiff
path: root/src/pkg/compress
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/compress')
-rw-r--r--src/pkg/compress/flate/deflate.go70
-rw-r--r--src/pkg/compress/flate/deflate_test.go14
-rw-r--r--src/pkg/compress/flate/flate_test.go6
-rw-r--r--src/pkg/compress/flate/huffman_bit_writer.go50
-rw-r--r--src/pkg/compress/flate/huffman_code.go22
-rw-r--r--src/pkg/compress/flate/inflate.go104
-rw-r--r--src/pkg/compress/flate/reverse_bits.go4
-rw-r--r--src/pkg/compress/flate/token.go8
-rw-r--r--src/pkg/compress/flate/util.go20
-rw-r--r--src/pkg/compress/gzip/gunzip.go38
-rw-r--r--src/pkg/compress/gzip/gunzip_test.go6
-rw-r--r--src/pkg/compress/zlib/reader.go16
-rw-r--r--src/pkg/compress/zlib/reader_test.go6
-rw-r--r--src/pkg/compress/zlib/writer.go22
-rw-r--r--src/pkg/compress/zlib/writer_test.go6
15 files changed, 196 insertions, 196 deletions
diff --git a/src/pkg/compress/flate/deflate.go b/src/pkg/compress/flate/deflate.go
index 79b8ec3ba..4b6726e30 100644
--- a/src/pkg/compress/flate/deflate.go
+++ b/src/pkg/compress/flate/deflate.go
@@ -132,15 +132,15 @@ func (d *deflater) fillWindow(index int) (int, os.Error) {
index -= wSize;
d.windowEnd -= wSize;
if d.blockStart >= wSize {
- d.blockStart -= wSize;
+ d.blockStart -= wSize
} else {
- d.blockStart = math.MaxInt32;
+ d.blockStart = math.MaxInt32
}
for i, h := range d.hashHead {
- d.hashHead[i] = max(h-wSize, -1);
+ d.hashHead[i] = max(h-wSize, -1)
}
for i, h := range d.hashPrev {
- d.hashPrev[i] = max(h-wSize, -1);
+ d.hashPrev[i] = max(h-wSize, -1)
}
}
var count int;
@@ -148,7 +148,7 @@ func (d *deflater) fillWindow(index int) (int, os.Error) {
count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd : len(d.window)], 1);
d.windowEnd += count;
if err == os.EOF {
- return index, nil;
+ return index, nil
}
return index, err;
}
@@ -157,7 +157,7 @@ func (d *deflater) writeBlock(tokens []token, index int, eof bool) os.Error {
if index > 0 || eof {
var window []byte;
if d.blockStart <= index {
- window = d.window[d.blockStart : index];
+ window = d.window[d.blockStart : index]
}
d.blockStart = index;
d.w.writeBlock(tokens, eof, window);
@@ -178,7 +178,7 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in
tries := d.maxChainLength;
length = prevLength;
if length >= d.goodMatch {
- tries >>= 2;
+ tries >>= 2
}
w0 := win[pos];
@@ -192,7 +192,7 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in
n := 3;
for pos+n < len(win) && win[i+n] == win[pos+n] {
- n++;
+ n++
}
if n > length && (n > 3 || pos-i <= 4096) {
length = n;
@@ -200,17 +200,17 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in
ok = true;
if n >= nice {
// The match is good enough that we don't try to find a better one.
- break;
+ break
}
wEnd = win[pos+n];
}
}
if i == minIndex {
// hashPrev[i & windowMask] has already been overwritten, so stop now.
- break;
+ break
}
if i = d.hashPrev[i & d.windowMask]; i < minIndex || i < 0 {
- break;
+ break
}
}
return;
@@ -218,7 +218,7 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in
func (d *deflater) writeStoredBlock(buf []byte) os.Error {
if d.w.writeStoredHeader(len(buf), false); d.w.err != nil {
- return d.w.err;
+ return d.w.err
}
d.w.writeBytes(buf);
return d.w.err;
@@ -230,12 +230,12 @@ func (d *deflater) storedDeflate() os.Error {
n, err := d.r.Read(buf);
if n > 0 {
if err := d.writeStoredBlock(buf[0:n]); err != nil {
- return err;
+ return err
}
}
if err != nil {
if err == os.EOF {
- break;
+ break
}
return err;
}
@@ -263,7 +263,7 @@ func (d *deflater) doDeflate() (err os.Error) {
index := 0;
// run
if index, err = d.fillWindow(index); err != nil {
- return;
+ return
}
maxOffset := d.windowMask + 1; // (1 << logWindowSize);
// only need to change when you refill the window
@@ -273,26 +273,26 @@ func (d *deflater) doDeflate() (err os.Error) {
hash := int(0);
if index < maxInsertIndex {
- hash = int(d.window[index]) << hashShift + int(d.window[index+1]);
+ hash = int(d.window[index]) << hashShift + int(d.window[index+1])
}
chainHead := -1;
for {
if index > windowEnd {
- panic("index > windowEnd");
+ panic("index > windowEnd")
}
lookahead := windowEnd - index;
if lookahead < minMatchLength + maxMatchLength {
if index, err = d.fillWindow(index); err != nil {
- return;
+ return
}
windowEnd = d.windowEnd;
if index > windowEnd {
- panic("index > windowEnd");
+ panic("index > windowEnd")
}
maxInsertIndex = windowEnd - (minMatchLength - 1);
lookahead = windowEnd - index;
if lookahead == 0 {
- break;
+ break
}
}
if index < maxInsertIndex {
@@ -321,9 +321,9 @@ func (d *deflater) doDeflate() (err os.Error) {
// There was a match at the previous step, and the current match is
// not better. Output the previous match.
if isFastDeflate {
- tokens[ti] = matchToken(uint32(length - minMatchLength), uint32(offset - minOffsetSize));
+ tokens[ti] = matchToken(uint32(length - minMatchLength), uint32(offset - minOffsetSize))
} else {
- tokens[ti] = matchToken(uint32(prevLength - minMatchLength), uint32(prevOffset - minOffsetSize));
+ tokens[ti] = matchToken(uint32(prevLength - minMatchLength), uint32(prevOffset - minOffsetSize))
}
ti++;
// Insert in the hash table all strings up to the end of the match.
@@ -333,9 +333,9 @@ func (d *deflater) doDeflate() (err os.Error) {
if length <= l.fastSkipHashing {
var newIndex int;
if isFastDeflate {
- newIndex = index+length;
+ newIndex = index+length
} else {
- newIndex = prevLength - 1;
+ newIndex = prevLength - 1
}
for index++; index < newIndex; index++ {
if index < maxInsertIndex {
@@ -360,7 +360,7 @@ func (d *deflater) doDeflate() (err os.Error) {
if ti == maxFlateBlockTokens {
// The block includes the current character
if err = d.writeBlock(tokens, index, false); err != nil {
- return;
+ return
}
ti = 0;
}
@@ -368,20 +368,20 @@ func (d *deflater) doDeflate() (err os.Error) {
if isFastDeflate || byteAvailable {
i := index-1;
if isFastDeflate {
- i = index;
+ i = index
}
tokens[ti] = literalToken(uint32(d.window[i])&0xFF);
ti++;
if ti == maxFlateBlockTokens {
if err = d.writeBlock(tokens, i+1, false); err != nil {
- return;
+ return
}
ti = 0;
}
}
index++;
if !isFastDeflate {
- byteAvailable = true;
+ byteAvailable = true
}
}
@@ -394,7 +394,7 @@ func (d *deflater) doDeflate() (err os.Error) {
if ti > 0 {
if err = d.writeBlock(tokens[0:ti], index, false); err != nil {
- return;
+ return
}
}
return;
@@ -408,21 +408,21 @@ func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize u
switch {
case level == NoCompression:
- err = d.storedDeflate();
+ err = d.storedDeflate()
case level == DefaultCompression:
d.level = 6;
fallthrough;
case 1 <= level && level <= 9:
- err = d.doDeflate();
+ err = d.doDeflate()
default:
- return WrongValueError{"level", 0, 9, int32(level)};
+ return WrongValueError{"level", 0, 9, int32(level)}
}
if err != nil {
- return err;
+ return err
}
if d.w.writeStoredHeader(0, true); d.w.err != nil {
- return d.w.err;
+ return d.w.err
}
return d.flush();
}
@@ -438,5 +438,5 @@ func newDeflater(w io.Writer, level int, logWindowSize uint) io.WriteCloser {
}
func NewDeflater(w io.Writer, level int) io.WriteCloser {
- return newDeflater(w, level, logMaxOffsetSize);
+ return newDeflater(w, level, logMaxOffsetSize)
}
diff --git a/src/pkg/compress/flate/deflate_test.go b/src/pkg/compress/flate/deflate_test.go
index 3f6c60bf5..85cc12d38 100644
--- a/src/pkg/compress/flate/deflate_test.go
+++ b/src/pkg/compress/flate/deflate_test.go
@@ -72,7 +72,7 @@ var reverseBitsTests = []*reverseBitsTest{
func getLargeDataChunk() []byte {
result := make([]byte, 100000);
for i := range result {
- result[i] = byte(int64(i)*int64(i)&0xFF);
+ result[i] = byte(int64(i)*int64(i)&0xFF)
}
return result;
}
@@ -85,7 +85,7 @@ func TestDeflate(t *testing.T) {
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);
+ h.level, buffer.Bytes(), h.out)
}
}
}
@@ -103,20 +103,20 @@ func testToFromWithLevel(t *testing.T, level int, input []byte, name string) os.
}
inflater.Close();
if bytes.Compare(input, decompressed) != 0 {
- t.Errorf("decompress(compress(data)) != data: level=%d input=%s", level, name);
+ t.Errorf("decompress(compress(data)) != data: level=%d input=%s", level, name)
}
return nil;
}
func testToFrom(t *testing.T, input []byte, name string) {
for i := 0; i < 10; i++ {
- testToFromWithLevel(t, i, input, name);
+ testToFromWithLevel(t, i, input, name)
}
}
func TestDeflateInflate(t *testing.T) {
for i, h := range deflateInflateTests {
- testToFrom(t, h.in, fmt.Sprintf("#%d", i));
+ testToFrom(t, h.in, fmt.Sprintf("#%d", i))
}
}
@@ -124,7 +124,7 @@ func TestReverseBits(t *testing.T) {
for _, h := range reverseBitsTests {
if v := reverseBits(h.in, h.bitCount); v != h.out {
t.Errorf("reverseBits(%v,%v) = %v, want %v",
- h.in, h.bitCount, v, h.out);
+ h.in, h.bitCount, v, h.out)
}
}
}
@@ -260,5 +260,5 @@ func getEdata() string {
"30186739439716388611764209004068663398856841681003872389214483176070116684503887" +
"21236436704331409115573328018297798873659091665961240202177855885487617616198937" +
"07943800566633648843650891448055710397652146960276625835990519870423001794655367" +
- "9";
+ "9"
}
diff --git a/src/pkg/compress/flate/flate_test.go b/src/pkg/compress/flate/flate_test.go
index ab7ce250b..e2a97b368 100644
--- a/src/pkg/compress/flate/flate_test.go
+++ b/src/pkg/compress/flate/flate_test.go
@@ -121,7 +121,7 @@ func TestInitDecoder(t *testing.T) {
continue;
}
if !reflect.DeepEqual(&h, &tt.out) {
- t.Errorf("test %d:\nhave %v\nwant %v", i, h, tt.out);
+ t.Errorf("test %d:\nhave %v\nwant %v", i, h, tt.out)
}
}
}
@@ -131,9 +131,9 @@ func TestUncompressedSource(t *testing.T) {
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);
+ t.Fatalf("decoder.Read() = %d, %v, want 1, nil", n, error)
}
if output[0] != 0x11 {
- t.Errorf("output[0] = %x, want 0x11", output[0]);
+ t.Errorf("output[0] = %x, want 0x11", output[0])
}
}
diff --git a/src/pkg/compress/flate/huffman_bit_writer.go b/src/pkg/compress/flate/huffman_bit_writer.go
index e81c6e6e0..44cb9811b 100644
--- a/src/pkg/compress/flate/huffman_bit_writer.go
+++ b/src/pkg/compress/flate/huffman_bit_writer.go
@@ -106,12 +106,12 @@ func newHuffmanBitWriter(w io.Writer) *huffmanBitWriter {
literalEncoding: newHuffmanEncoder(maxLit),
offsetEncoding: newHuffmanEncoder(extendedOffsetCodeCount),
codegenEncoding: newHuffmanEncoder(codegenCodeCount),
- };
+ }
}
func (err WrongValueError) String() string {
return "huffmanBitWriter: " + err.name + " should belong to [" + strconv.Itoa64(int64(err.from)) + ";" +
- strconv.Itoa64(int64(err.to)) + "] but actual value is " + strconv.Itoa64(int64(err.value));
+ strconv.Itoa64(int64(err.to)) + "] but actual value is " + strconv.Itoa64(int64(err.value))
}
func (w *huffmanBitWriter) flushBits() {
@@ -157,13 +157,13 @@ func (w *huffmanBitWriter) flush() {
func (w *huffmanBitWriter) writeBits(b, nb int32) {
w.bits |= uint32(b) << w.nbits;
if w.nbits += uint32(nb); w.nbits >= 16 {
- w.flushBits();
+ w.flushBits()
}
}
func (w *huffmanBitWriter) writeBytes(bytes []byte) {
if w.err != nil {
- return;
+ return
}
n := w.nbytes;
if w.nbits == 8 {
@@ -178,7 +178,7 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) {
if n != 0 {
_, w.err = w.w.Write(w.bytes[0:n]);
if w.err != nil {
- return;
+ return
}
}
w.nbytes = 0;
@@ -270,7 +270,7 @@ func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int) {
func (w *huffmanBitWriter) writeCode(code *huffmanEncoder, literal uint32) {
if w.err != nil {
- return;
+ return
}
w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal]));
}
@@ -282,11 +282,11 @@ func (w *huffmanBitWriter) writeCode(code *huffmanEncoder, literal uint32) {
// numCodegens Tne number of codegens used in codegen
func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, numCodegens int, isEof bool) {
if w.err != nil {
- return;
+ return
}
var firstBits int32 = 4;
if isEof {
- firstBits = 5;
+ firstBits = 5
}
w.writeBits(firstBits, 3);
w.writeBits(int32(numLiterals - 257), 5);
@@ -295,7 +295,7 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
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(numOffsets - 1), 5)
}
w.writeBits(int32(numCodegens - 4), 4);
@@ -309,7 +309,7 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
var codeWord int = int(w.codegen[i]);
i++;
if codeWord == badCode {
- break;
+ break
}
// The low byte contains the actual code to generate.
w.writeCode(w.codegenEncoding, uint32(codeWord));
@@ -333,11 +333,11 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n
func (w *huffmanBitWriter) writeStoredHeader(length int, isEof bool) {
if w.err != nil {
- return;
+ return
}
var flag int32;
if isEof {
- flag = 1;
+ flag = 1
}
w.writeBits(flag, 3);
w.flush();
@@ -347,19 +347,19 @@ func (w *huffmanBitWriter) writeStoredHeader(length int, isEof bool) {
func (w *huffmanBitWriter) writeFixedHeader(isEof bool) {
if w.err != nil {
- return;
+ return
}
// Indicate that we are a fixed Huffman block
var value int32 = 2;
if isEof {
- value = 3;
+ value = 3
}
w.writeBits(value, 3);
}
func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
if w.err != nil {
- return;
+ return
}
fillInt32s(w.literalFreq, 0);
fillInt32s(w.offsetFreq, 0);
@@ -390,16 +390,16 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
// get the number of literals
numLiterals := len(w.literalFreq);
for w.literalFreq[numLiterals - 1] == 0 {
- numLiterals--;
+ numLiterals--
}
// get the number of offsets
numOffsets := len(w.offsetFreq);
for numOffsets > 1 && w.offsetFreq[numOffsets - 1] == 0 {
- numOffsets--;
+ numOffsets--
}
storedBytes := 0;
if input != nil {
- storedBytes = len(input);
+ storedBytes = len(input)
}
var extraBits int64;
var storedSize int64;
@@ -411,14 +411,14 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
// against stored encoding.
for lengthCode := lengthCodesStart + 8; lengthCode < numLiterals; lengthCode++ {
// First eight length codes have extra size = 0.
- extraBits += int64(w.literalFreq[lengthCode])*int64(lengthExtraBits[lengthCode - lengthCodesStart]);
+ extraBits += int64(w.literalFreq[lengthCode])*int64(lengthExtraBits[lengthCode - lengthCodesStart])
}
for offsetCode := 4; offsetCode < numOffsets; offsetCode++ {
// First four offset codes have extra size = 0.
- extraBits += int64(w.offsetFreq[offsetCode])*int64(offsetExtraBits[offsetCode]);
+ extraBits += int64(w.offsetFreq[offsetCode])*int64(offsetExtraBits[offsetCode])
}
} else {
- storedSize = math.MaxInt32;
+ storedSize = math.MaxInt32
}
// Figure out which generates smaller code, fixed Huffman, dynamic
@@ -428,7 +428,7 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
fixedSize = int64(3) +
fixedLiteralEncoding.bitLength(w.literalFreq) +
fixedOffsetEncoding.bitLength(w.offsetFreq) +
- extraBits;
+ extraBits
}
// Generate codegen and codegenFrequencies, which indicates how to encode
// the literalEncoding and the offsetEncoding.
@@ -436,11 +436,11 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
w.codegenEncoding.generate(w.codegenFreq, 7);
numCodegens := len(w.codegenFreq);
for numCodegens > 4 && w.codegenFreq[codegenOrder[numCodegens - 1]] == 0 {
- numCodegens--;
+ numCodegens--
}
extensionSummand := 0;
if numOffsets > offsetCodeCount {
- extensionSummand = 3;
+ extensionSummand = 3
}
dynamicHeader := int64(3+5+5+4+(3 * numCodegens)) +
// Following line is an extension.
@@ -500,7 +500,7 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) {
}
break;
default:
- panic("unknown token type: " + string(t));
+ 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 eecfceb9c..c3cd482dc 100644
--- a/src/pkg/compress/flate/huffman_code.go
+++ b/src/pkg/compress/flate/huffman_code.go
@@ -58,7 +58,7 @@ type levelInfo struct {
func maxNode() literalNode { 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
@@ -115,7 +115,7 @@ 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;
@@ -163,14 +163,14 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) {
up := l.up;
if up == nil {
// All done!
- return;
+ return
}
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 {
- l = l.down;
+ l = l.down
}
}
}
@@ -215,7 +215,7 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
};
top.down.up = top;
if level == 1 {
- top.nextPairFreq = math.MaxInt32;
+ top.nextPairFreq = math.MaxInt32
}
}
@@ -258,14 +258,14 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
up := l.up;
if up == nil {
// All done!
- break;
+ break
}
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 {
- l = l.down;
+ l = l.down
}
}
}
@@ -274,7 +274,7 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
// Somethings is wrong if at the end, the top level is null or hasn't used
// all of the leaves.
if top.lastChain.leafCount != n {
- panic("top.lastChain.leafCount != n");
+ panic("top.lastChain.leafCount != n")
}
bitCount := make([]int32, maxBits+1);
@@ -295,7 +295,7 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
for n, bits := range bitCount {
code <<= 1;
if n == 0 || bits == 0 {
- continue;
+ continue
}
// The literals list[len(list)-bits] .. list[len(list)-bits]
// are encoded using "bits" bits, and get the values
@@ -326,7 +326,7 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
list[count] = literalNode{uint16(i), f};
count++;
} else {
- h.codeBits[i] = 0;
+ h.codeBits[i] = 0
}
}
// If freq[] is shorter than codeBits[], fill rest of codeBits[] with zeros
@@ -358,7 +358,7 @@ type literalNodeSorter struct {
func (s literalNodeSorter) Len() int { return len(s.a) }
func (s literalNodeSorter) Less(i, j int) bool {
- return s.less(i, j);
+ return s.less(i, j)
}
func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
diff --git a/src/pkg/compress/flate/inflate.go b/src/pkg/compress/flate/inflate.go
index a39166d96..5bdd5cfae 100644
--- a/src/pkg/compress/flate/inflate.go
+++ b/src/pkg/compress/flate/inflate.go
@@ -26,7 +26,7 @@ const (
type CorruptInputError int64
func (e CorruptInputError) String() string {
- return "flate: corrupt input before offset " + strconv.Itoa64(int64(e));
+ return "flate: corrupt input before offset " + strconv.Itoa64(int64(e))
}
// An InternalError reports an error in the flate code itself.
@@ -41,7 +41,7 @@ type ReadError struct {
}
func (e *ReadError) String() string {
- return "flate: read error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Error.String();
+ return "flate: read error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Error.String()
}
// A WriteError reports an error encountered while writing output.
@@ -51,7 +51,7 @@ type WriteError struct {
}
func (e *WriteError) String() string {
- return "flate: write error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Error.String();
+ return "flate: write error at offset " + strconv.Itoa64(e.Offset) + ": " + e.Error.String()
}
// Huffman decoder is based on
@@ -85,18 +85,18 @@ func (h *huffmanDecoder) init(bits []int) bool {
var min, max int;
for _, n := range bits {
if n == 0 {
- continue;
+ continue
}
if min == 0 || n < min {
- min = n;
+ min = n
}
if n > max {
- max = n;
+ max = n
}
count[n]++;
}
if max == 0 {
- return false;
+ return false
}
h.min = min;
@@ -122,11 +122,11 @@ func (h *huffmanDecoder) init(bits []int) bool {
// Make array mapping sequence numbers to codes.
if len(h.codes) < len(bits) {
- h.codes = make([]int, len(bits));
+ h.codes = make([]int, len(bits))
}
for i, n := range bits {
if n == 0 {
- continue;
+ continue
}
code := nextcode[n];
nextcode[n]++;
@@ -229,7 +229,7 @@ func (f *inflater) inflate() (err os.Error) {
for err == nil && !final {
for f.nb < 1+2 {
if err = f.moreBits(); err != nil {
- return;
+ return
}
}
final = f.b & 1 == 1;
@@ -239,18 +239,18 @@ func (f *inflater) inflate() (err os.Error) {
f.nb -= 1+2;
switch typ {
case 0:
- err = f.dataBlock();
+ err = f.dataBlock()
case 1:
// compressed, fixed Huffman tables
- err = f.decodeBlock(&fixedHuffmanDecoder, nil);
+ err = f.decodeBlock(&fixedHuffmanDecoder, nil)
case 2:
// compressed, dynamic Huffman tables
if err = f.readHuffman(); err == nil {
- err = f.decodeBlock(&f.h1, &f.h2);
+ err = f.decodeBlock(&f.h1, &f.h2)
}
default:
// 3 is reserved.
- err = CorruptInputError(f.roffset);
+ err = CorruptInputError(f.roffset)
}
}
return;
@@ -265,7 +265,7 @@ func (f *inflater) readHuffman() os.Error {
// HLIT[5], HDIST[5], HCLEN[4].
for f.nb < 5+5+4 {
if err := f.moreBits(); err != nil {
- return err;
+ return err
}
}
nlit := int(f.b & 0x1F)+257;
@@ -280,7 +280,7 @@ func (f *inflater) readHuffman() os.Error {
for i := 0; i < nclen; i++ {
for f.nb < 3 {
if err := f.moreBits(); err != nil {
- return err;
+ return err
}
}
f.codebits[codeOrder[i]] = int(f.b & 0x7);
@@ -288,10 +288,10 @@ func (f *inflater) readHuffman() os.Error {
f.nb -= 3;
}
for i := nclen; i < len(codeOrder); i++ {
- f.codebits[codeOrder[i]] = 0;
+ f.codebits[codeOrder[i]] = 0
}
if !f.h1.init(&f.codebits) {
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
}
// HLIT + 257 code lengths, HDIST + 1 code lengths,
@@ -299,7 +299,7 @@ func (f *inflater) readHuffman() os.Error {
for i, n := 0, nlit+ndist; i < n; {
x, err := f.huffSym(&f.h1);
if err != nil {
- return err;
+ return err
}
if x < 16 {
// Actual length.
@@ -313,12 +313,12 @@ func (f *inflater) readHuffman() os.Error {
var b int;
switch x {
default:
- return InternalError("unexpected length code");
+ return InternalError("unexpected length code")
case 16:
rep = 3;
nb = 2;
if i == 0 {
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
}
b = f.bits[i-1];
case 17:
@@ -332,14 +332,14 @@ func (f *inflater) readHuffman() os.Error {
}
for f.nb < nb {
if err := f.moreBits(); err != nil {
- return err;
+ return err
}
}
rep += int(f.b & uint32(1<<nb - 1));
f.b >>= nb;
f.nb -= nb;
if i+rep > n {
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
}
for j := 0; j < rep; j++ {
f.bits[i] = b;
@@ -348,7 +348,7 @@ func (f *inflater) readHuffman() os.Error {
}
if !f.h1.init(f.bits[0:nlit]) || !f.h2.init(f.bits[nlit : nlit+ndist]) {
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
}
return nil;
@@ -362,7 +362,7 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
for {
v, err := f.huffSym(hl);
if err != nil {
- return err;
+ return err
}
var n uint; // number of bits extra
var length int;
@@ -372,12 +372,12 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
f.hp++;
if f.hp == len(f.hist) {
if err = f.flush(); err != nil {
- return err;
+ return err
}
}
continue;
case v == 256:
- return nil;
+ return nil
// otherwise, reference to older data
case v < 265:
length = v-(257-3);
@@ -404,7 +404,7 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
if n > 0 {
for f.nb < n {
if err = f.moreBits(); err != nil {
- return err;
+ return err
}
}
length += int(f.b & uint32(1<<n - 1));
@@ -416,7 +416,7 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
if hd == nil {
for f.nb < 5 {
if err = f.moreBits(); err != nil {
- return err;
+ return err
}
}
dist = int(reverseByte[(f.b & 0x1F)<<3]);
@@ -424,22 +424,22 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
f.nb -= 5;
} else {
if dist, err = f.huffSym(hd); err != nil {
- return err;
+ return err
}
}
switch {
case dist < 4:
- dist++;
+ dist++
case dist >= 30:
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
default:
nb := uint(dist-2)>>1;
// have 1 bit in bottom of dist, need nb more.
extra := (dist&1)<<nb;
for f.nb < nb {
if err = f.moreBits(); err != nil {
- return err;
+ return err
}
}
extra |= int(f.b & uint32(1<<nb - 1));
@@ -450,17 +450,17 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
// Copy history[-dist:-dist+length] into output.
if dist > len(f.hist) {
- return InternalError("bad history distance");
+ return InternalError("bad history distance")
}
// No check on length; encoding can be prescient.
if !f.hfull && dist > f.hp {
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
}
p := f.hp - dist;
if p < 0 {
- p += len(f.hist);
+ p += len(f.hist)
}
for i := 0; i < length; i++ {
f.hist[f.hp] = f.hist[p];
@@ -468,11 +468,11 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error {
p++;
if f.hp == len(f.hist) {
if err = f.flush(); err != nil {
- return err;
+ return err
}
}
if p == len(f.hist) {
- p = 0;
+ p = 0
}
}
}
@@ -490,12 +490,12 @@ func (f *inflater) dataBlock() os.Error {
nr, err := io.ReadFull(f.r, f.buf[0:4]);
f.roffset += int64(nr);
if err != nil {
- return &ReadError{f.roffset, err};
+ 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;
if uint16(nn) != uint16(^n) {
- return CorruptInputError(f.roffset);
+ return CorruptInputError(f.roffset)
}
// Read len bytes into history,
@@ -503,18 +503,18 @@ func (f *inflater) dataBlock() os.Error {
for n > 0 {
m := len(f.hist) - f.hp;
if m > n {
- m = n;
+ m = n
}
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};
+ return &ReadError{f.roffset, err}
}
n -= m;
f.hp += m;
if f.hp == len(f.hist) {
if err = f.flush(); err != nil {
- return err;
+ return err
}
}
}
@@ -525,7 +525,7 @@ func (f *inflater) moreBits() os.Error {
c, err := f.r.ReadByte();
if err != nil {
if err == os.EOF {
- err = io.ErrUnexpectedEOF;
+ err = io.ErrUnexpectedEOF
}
return err;
}
@@ -540,11 +540,11 @@ func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) {
for n := uint(h.min); n <= uint(h.max); n++ {
lim := h.limit[n];
if lim == -1 {
- continue;
+ continue
}
for f.nb < n {
if err := f.moreBits(); err != nil {
- return 0, err;
+ return 0, err
}
}
v := int(f.b & uint32(1<<n - 1));
@@ -562,14 +562,14 @@ func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) {
// Flush any buffered output to the underlying writer.
func (f *inflater) flush() os.Error {
if f.hp == 0 {
- return nil;
+ return nil
}
n, err := f.w.Write(f.hist[0 : f.hp]);
if n != f.hp && err == nil {
- err = io.ErrShortWrite;
+ err = io.ErrShortWrite
}
if err != nil {
- return &WriteError{f.woffset, err};
+ return &WriteError{f.woffset, err}
}
f.woffset += int64(f.hp);
f.hp = 0;
@@ -579,7 +579,7 @@ func (f *inflater) flush() os.Error {
func makeReader(r io.Reader) Reader {
if rr, ok := r.(Reader); ok {
- return rr;
+ return rr
}
return bufio.NewReader(r);
}
@@ -591,10 +591,10 @@ func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error {
f.w = w;
f.woffset = 0;
if err := f.inflate(); err != nil {
- return err;
+ return err
}
if err := f.flush(); err != nil {
- return err;
+ return err
}
return nil;
}
diff --git a/src/pkg/compress/flate/reverse_bits.go b/src/pkg/compress/flate/reverse_bits.go
index 76693d475..8376da32a 100644
--- a/src/pkg/compress/flate/reverse_bits.go
+++ b/src/pkg/compress/flate/reverse_bits.go
@@ -40,9 +40,9 @@ var reverseByte = [256]byte{
}
func reverseUint16(v uint16) uint16 {
- return uint16(reverseByte[v>>8]) | uint16(reverseByte[v&0xFF])<<8;
+ return uint16(reverseByte[v>>8]) | uint16(reverseByte[v&0xFF])<<8
}
func reverseBits(number uint16, bitLength byte) uint16 {
- return reverseUint16(number<<uint8(16 - bitLength));
+ return reverseUint16(number<<uint8(16 - bitLength))
}
diff --git a/src/pkg/compress/flate/token.go b/src/pkg/compress/flate/token.go
index d37730ca5..5d4bcefaf 100644
--- a/src/pkg/compress/flate/token.go
+++ b/src/pkg/compress/flate/token.go
@@ -72,7 +72,7 @@ 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 {
- return token(matchType + xlength << lengthShift + xoffset);
+ return token(matchType + xlength << lengthShift + xoffset)
}
// Returns the type of a token
@@ -93,11 +93,11 @@ func offsetCode(off uint32) uint32 {
const n = uint32(len(offsetCodes));
switch {
case off < n:
- return offsetCodes[off];
+ return offsetCodes[off]
case off>>7 < n:
- return offsetCodes[off>>7] + 14;
+ return offsetCodes[off>>7] + 14
default:
- return offsetCodes[off>>14] + 28;
+ return offsetCodes[off>>14] + 28
}
panic("unreachable");
}
diff --git a/src/pkg/compress/flate/util.go b/src/pkg/compress/flate/util.go
index 177ee21d6..f4e0b9ba3 100644
--- a/src/pkg/compress/flate/util.go
+++ b/src/pkg/compress/flate/util.go
@@ -6,59 +6,59 @@ package flate
func min(left int, right int) int {
if left < right {
- return left;
+ return left
}
return right;
}
func minInt32(left int32, right int32) int32 {
if left < right {
- return left;
+ return left
}
return right;
}
func max(left int, right int) int {
if left > right {
- return left;
+ return left
}
return right;
}
func fillInts(a []int, value int) {
for i := range a {
- a[i] = value;
+ a[i] = value
}
}
func fillInt32s(a []int32, value int32) {
for i := range a {
- a[i] = value;
+ a[i] = value
}
}
func fillBytes(a []byte, value byte) {
for i := range a {
- a[i] = value;
+ a[i] = value
}
}
func fillInt8s(a []int8, value int8) {
for i := range a {
- a[i] = value;
+ a[i] = value
}
}
func fillUint8s(a []uint8, value uint8) {
for i := range a {
- a[i] = value;
+ a[i] = value
}
}
func copyInt8s(dst []int8, src []int8) int {
cnt := min(len(dst), len(src));
for i := 0; i < cnt; i++ {
- dst[i] = src[i];
+ dst[i] = src[i]
}
return cnt;
}
@@ -66,7 +66,7 @@ func copyInt8s(dst []int8, src []int8) int {
func copyUint8s(dst []uint8, src []uint8) int {
cnt := min(len(dst), len(src));
for i := 0; i < cnt; i++ {
- dst[i] = src[i];
+ dst[i] = src[i]
}
return cnt;
}
diff --git a/src/pkg/compress/gzip/gunzip.go b/src/pkg/compress/gzip/gunzip.go
index 3dbfeca65..8dc64fea3 100644
--- a/src/pkg/compress/gzip/gunzip.go
+++ b/src/pkg/compress/gzip/gunzip.go
@@ -28,7 +28,7 @@ const (
func makeReader(r io.Reader) flate.Reader {
if rr, ok := r.(flate.Reader); ok {
- return rr;
+ return rr
}
return bufio.NewReader(r);
}
@@ -85,21 +85,21 @@ func NewInflater(r io.Reader) (*Inflater, os.Error) {
// GZIP (RFC 1952) is little-endian, unlike ZLIB (RFC 1950).
func get4(p []byte) uint32 {
- return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24;
+ return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
}
func (z *Inflater) readString() (string, os.Error) {
var err os.Error;
for i := 0; ; i++ {
if i >= len(z.buf) {
- return "", HeaderError;
+ return "", HeaderError
}
z.buf[i], err = z.r.ReadByte();
if err != nil {
- return "", err;
+ return "", err
}
if z.buf[i] == 0 {
- return string(z.buf[0:i]), nil;
+ return string(z.buf[0:i]), nil
}
}
panic("not reached");
@@ -108,7 +108,7 @@ func (z *Inflater) readString() (string, os.Error) {
func (z *Inflater) read2() (uint32, os.Error) {
_, err := z.r.Read(z.buf[0:2]);
if err != nil {
- return 0, err;
+ return 0, err
}
return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil;
}
@@ -116,10 +116,10 @@ func (z *Inflater) read2() (uint32, os.Error) {
func (z *Inflater) readHeader(save bool) os.Error {
_, err := io.ReadFull(z.r, z.buf[0:10]);
if err != nil {
- return err;
+ return err
}
if z.buf[0] != gzipID1 || z.buf[1] != gzipID2 || z.buf[2] != gzipDeflate {
- return HeaderError;
+ return HeaderError
}
z.flg = z.buf[3];
if save {
@@ -133,44 +133,44 @@ func (z *Inflater) readHeader(save bool) os.Error {
if z.flg & flagExtra != 0 {
n, err := z.read2();
if err != nil {
- return err;
+ return err
}
data := make([]byte, n);
if _, err = io.ReadFull(z.r, data); err != nil {
- return err;
+ return err
}
if save {
- z.Extra = data;
+ z.Extra = data
}
}
var s string;
if z.flg & flagName != 0 {
if s, err = z.readString(); err != nil {
- return err;
+ return err
}
if save {
- z.Name = s;
+ z.Name = s
}
}
if z.flg & flagComment != 0 {
if s, err = z.readString(); err != nil {
- return err;
+ return err
}
if save {
- z.Comment = s;
+ z.Comment = s
}
}
if z.flg & flagHdrCrc != 0 {
n, err := z.read2();
if err != nil {
- return err;
+ return err
}
sum := z.digest.Sum32() & 0xFFFF;
if n != sum {
- return HeaderError;
+ return HeaderError
}
}
@@ -181,10 +181,10 @@ func (z *Inflater) readHeader(save bool) os.Error {
func (z *Inflater) Read(p []byte) (n int, err os.Error) {
if z.err != nil {
- return 0, z.err;
+ return 0, z.err
}
if z.eof || len(p) == 0 {
- return 0, nil;
+ return 0, nil
}
n, err = z.inflater.Read(p);
diff --git a/src/pkg/compress/gzip/gunzip_test.go b/src/pkg/compress/gzip/gunzip_test.go
index 08e1a5967..84286ee3f 100644
--- a/src/pkg/compress/gzip/gunzip_test.go
+++ b/src/pkg/compress/gzip/gunzip_test.go
@@ -290,16 +290,16 @@ func TestInflater(t *testing.T) {
}
defer gzip.Close();
if tt.name != gzip.Name {
- t.Errorf("%s: got name %s", tt.name, gzip.Name);
+ t.Errorf("%s: got name %s", tt.name, gzip.Name)
}
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);
+ t.Errorf("%s: io.Copy: %v want %v", tt.name, err, tt.err)
}
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);
+ 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 cf0eb1b29..c00258995 100644
--- a/src/pkg/compress/zlib/reader.go
+++ b/src/pkg/compress/zlib/reader.go
@@ -35,21 +35,21 @@ type reader struct {
func NewInflater(r io.Reader) (io.ReadCloser, os.Error) {
z := new(reader);
if fr, ok := r.(flate.Reader); ok {
- z.r = fr;
+ z.r = fr
} else {
- z.r = bufio.NewReader(r);
+ z.r = bufio.NewReader(r)
}
_, err := io.ReadFull(z.r, z.scratch[0:2]);
if err != nil {
- return nil, err;
+ return nil, err
}
h := uint(z.scratch[0])<<8 | uint(z.scratch[1]);
if (z.scratch[0] & 0x0f != zlibDeflate) || (h%31 != 0) {
- return nil, HeaderError;
+ return nil, HeaderError
}
if z.scratch[1] & 0x20 != 0 {
// BUG(nigeltao): The zlib package does not implement the FDICT flag.
- return nil, UnsupportedError;
+ return nil, UnsupportedError
}
z.digest = adler32.New();
z.inflater = flate.NewInflater(z.r);
@@ -58,10 +58,10 @@ func NewInflater(r io.Reader) (io.ReadCloser, os.Error) {
func (z *reader) Read(p []byte) (n int, err os.Error) {
if z.err != nil {
- return 0, z.err;
+ return 0, z.err
}
if len(p) == 0 {
- return 0, nil;
+ return 0, nil
}
n, err = z.inflater.Read(p);
@@ -88,7 +88,7 @@ func (z *reader) Read(p []byte) (n int, err os.Error) {
// Calling Close does not close the wrapped io.Reader originally passed to NewInflater.
func (z *reader) Close() os.Error {
if z.err != nil {
- return z.err;
+ 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 037c9bf6f..5e057ee21 100644
--- a/src/pkg/compress/zlib/reader_test.go
+++ b/src/pkg/compress/zlib/reader_test.go
@@ -74,7 +74,7 @@ func TestInflater(t *testing.T) {
zlib, err := NewInflater(in);
if err != nil {
if err != tt.err {
- t.Errorf("%s: NewInflater: %s", tt.desc, err);
+ t.Errorf("%s: NewInflater: %s", tt.desc, err)
}
continue;
}
@@ -83,13 +83,13 @@ func TestInflater(t *testing.T) {
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);
+ t.Errorf("%s: io.Copy: %v want %v", tt.desc, err, tt.err)
}
continue;
}
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);
+ 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 6c0c0bbd4..9b23b2293 100644
--- a/src/pkg/compress/zlib/writer.go
+++ b/src/pkg/compress/zlib/writer.go
@@ -31,7 +31,7 @@ type writer struct {
// NewDeflater calls NewDeflaterLevel with the default compression level.
func NewDeflater(w io.Writer) (io.WriteCloser, os.Error) {
- return NewDeflaterLevel(w, DefaultCompression);
+ return NewDeflaterLevel(w, DefaultCompression)
}
// NewDeflater creates a new io.WriteCloser that satisfies writes by compressing data written to w.
@@ -50,19 +50,19 @@ func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
// The final five FCHECK bits form a mod-31 checksum.
switch level {
case 0, 1:
- z.scratch[1] = 0x01;
+ z.scratch[1] = 0x01
case 2, 3, 4, 5:
- z.scratch[1] = 0x5e;
+ z.scratch[1] = 0x5e
case 6, -1:
- z.scratch[1] = 0x9c;
+ z.scratch[1] = 0x9c
case 7, 8, 9:
- z.scratch[1] = 0xda;
+ z.scratch[1] = 0xda
default:
- return nil, os.NewError("level out of range");
+ return nil, os.NewError("level out of range")
}
_, err := w.Write(z.scratch[0:2]);
if err != nil {
- return nil, err;
+ return nil, err
}
z.w = w;
z.deflater = flate.NewDeflater(w, level);
@@ -72,10 +72,10 @@ func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
func (z *writer) Write(p []byte) (n int, err os.Error) {
if z.err != nil {
- return 0, z.err;
+ return 0, z.err
}
if len(p) == 0 {
- return 0, nil;
+ return 0, nil
}
n, err = z.deflater.Write(p);
if err != nil {
@@ -89,11 +89,11 @@ func (z *writer) Write(p []byte) (n int, err os.Error) {
// Calling Close does not close the wrapped io.Writer originally passed to NewDeflater.
func (z *writer) Close() os.Error {
if z.err != nil {
- return z.err;
+ return z.err
}
z.err = z.deflater.Close();
if z.err != nil {
- return z.err;
+ return z.err
}
checksum := z.digest.Sum32();
// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
diff --git a/src/pkg/compress/zlib/writer_test.go b/src/pkg/compress/zlib/writer_test.go
index 16e88a6a9..13c20d9d1 100644
--- a/src/pkg/compress/zlib/writer_test.go
+++ b/src/pkg/compress/zlib/writer_test.go
@@ -53,14 +53,14 @@ func testFileLevel(t *testing.T, fn string, level int) {
_, 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;
+ return
}
if err1 != nil {
t.Errorf("%s (level=%d): %v", fn, level, err1);
return;
}
if err0 == os.EOF {
- break;
+ break
}
}
}();
@@ -99,7 +99,7 @@ func TestWriter(t *testing.T) {
testFileLevel(t, fn, DefaultCompression);
testFileLevel(t, fn, NoCompression);
for level := BestSpeed; level <= BestCompression; level++ {
- testFileLevel(t, fn, level);
+ testFileLevel(t, fn, level)
}
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-03 23:21:08 +0000