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

	       2nd set of files.

R=rsc
CC=golang-dev
https://golang.org/cl/179067

12 files changed, 682 insertions, 682 deletions

diff --git a/src/pkg/encoding/ascii85/ascii85.go b/src/pkg/encoding/ascii85/ascii85.go
index ac446baf82..67d6ef7edf 100644
--- a/src/pkg/encoding/ascii85/ascii85.go
+++ b/src/pkg/encoding/ascii85/ascii85.go
@@ -7,9 +7,9 @@
 package ascii85
 
 import (
-	"io";
-	"os";
-	"strconv";
+	"io"
+	"os"
+	"strconv"
 )
 
 /*
@@ -30,74 +30,74 @@ func Encode(dst, src []byte) int {
 		return 0
 	}
 
-	n := 0;
+	n := 0
 	for len(src) > 0 {
-		dst[0] = 0;
-		dst[1] = 0;
-		dst[2] = 0;
-		dst[3] = 0;
-		dst[4] = 0;
+		dst[0] = 0
+		dst[1] = 0
+		dst[2] = 0
+		dst[3] = 0
+		dst[4] = 0
 
 		// Unpack 4 bytes into uint32 to repack into base 85 5-byte.
-		var v uint32;
+		var v uint32
 		switch len(src) {
 		default:
-			v |= uint32(src[3]);
-			fallthrough;
+			v |= uint32(src[3])
+			fallthrough
 		case 3:
-			v |= uint32(src[2]) << 8;
-			fallthrough;
+			v |= uint32(src[2]) << 8
+			fallthrough
 		case 2:
-			v |= uint32(src[1]) << 16;
-			fallthrough;
+			v |= uint32(src[1]) << 16
+			fallthrough
 		case 1:
 			v |= uint32(src[0]) << 24
 		}
 
 		// Special case: zero (!!!!!) shortens to z.
 		if v == 0 && len(src) >= 4 {
-			dst[0] = 'z';
-			dst = dst[1:];
-			n++;
-			continue;
+			dst[0] = 'z'
+			dst = dst[1:]
+			n++
+			continue
 		}
 
 		// Otherwise, 5 base 85 digits starting at !.
 		for i := 4; i >= 0; i-- {
-			dst[i] = '!' + byte(v%85);
-			v /= 85;
+			dst[i] = '!' + byte(v%85)
+			v /= 85
 		}
 
 		// If src was short, discard the low destination bytes.
-		m := 5;
+		m := 5
 		if len(src) < 4 {
-			m -= 4 - len(src);
-			src = nil;
+			m -= 4 - len(src)
+			src = nil
 		} else {
 			src = src[4:]
 		}
-		dst = dst[m:];
-		n += m;
+		dst = dst[m:]
+		n += m
 	}
-	return n;
+	return n
 }
 
 // MaxEncodedLen returns the maximum length of an encoding of n source bytes.
-func MaxEncodedLen(n int) int	{ return (n + 3) / 4 * 5 }
+func MaxEncodedLen(n int) int { return (n + 3) / 4 * 5 }
 
 // NewEncoder returns a new ascii85 stream encoder.  Data written to
 // the returned writer will be encoded and then written to w.
 // Ascii85 encodings operate in 32-bit blocks; when finished
 // writing, the caller must Close the returned encoder to flush any
 // trailing partial block.
-func NewEncoder(w io.Writer) io.WriteCloser	{ return &encoder{w: w} }
+func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} }
 
 type encoder struct {
-	err	os.Error;
-	w	io.Writer;
-	buf	[4]byte;	// buffered data waiting to be encoded
-	nbuf	int;		// number of bytes in buf
-	out	[1024]byte;	// output buffer
+	err  os.Error
+	w    io.Writer
+	buf  [4]byte    // buffered data waiting to be encoded
+	nbuf int        // number of bytes in buf
+	out  [1024]byte // output buffer
 }
 
 func (e *encoder) Write(p []byte) (n int, err os.Error) {
@@ -107,47 +107,47 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 
 	// Leading fringe.
 	if e.nbuf > 0 {
-		var i int;
+		var i int
 		for i = 0; i < len(p) && e.nbuf < 4; i++ {
-			e.buf[e.nbuf] = p[i];
-			e.nbuf++;
+			e.buf[e.nbuf] = p[i]
+			e.nbuf++
 		}
-		n += i;
-		p = p[i:];
+		n += i
+		p = p[i:]
 		if e.nbuf < 4 {
 			return
 		}
-		nout := Encode(&e.out, &e.buf);
+		nout := Encode(&e.out, &e.buf)
 		if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
 			return n, e.err
 		}
-		e.nbuf = 0;
+		e.nbuf = 0
 	}
 
 	// Large interior chunks.
 	for len(p) >= 4 {
-		nn := len(e.out) / 5 * 4;
+		nn := len(e.out) / 5 * 4
 		if nn > len(p) {
 			nn = len(p)
 		}
-		nn -= nn % 4;
+		nn -= nn % 4
 		if nn > 0 {
-			nout := Encode(&e.out, p[0:nn]);
+			nout := Encode(&e.out, p[0:nn])
 			if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
 				return n, e.err
 			}
 		}
-		n += nn;
-		p = p[nn:];
+		n += nn
+		p = p[nn:]
 	}
 
 	// Trailing fringe.
 	for i := 0; i < len(p); i++ {
 		e.buf[i] = p[i]
 	}
-	e.nbuf = len(p);
-	n += len(p);
-	return;
+	e.nbuf = len(p)
+	n += len(p)
+	return
 }
 
 // Close flushes any pending output from the encoder.
@@ -155,11 +155,11 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 func (e *encoder) Close() os.Error {
 	// If there's anything left in the buffer, flush it out
 	if e.err == nil && e.nbuf > 0 {
-		nout := Encode(&e.out, e.buf[0:e.nbuf]);
-		e.nbuf = 0;
-		_, e.err = e.w.Write(e.out[0:nout]);
+		nout := Encode(&e.out, e.buf[0:e.nbuf])
+		e.nbuf = 0
+		_, e.err = e.w.Write(e.out[0:nout])
 	}
-	return e.err;
+	return e.err
 }
 
 /*
@@ -187,8 +187,8 @@ func (e CorruptInputError) String() string {
 // NewDecoder wraps an io.Reader interface around Decode.
 //
 func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
-	var v uint32;
-	var nb int;
+	var v uint32
+	var nb int
 	for i, b := range src {
 		if len(dst)-ndst < 4 {
 			return
@@ -197,27 +197,27 @@ func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
 		case b <= ' ':
 			continue
 		case b == 'z' && nb == 0:
-			nb = 5;
-			v = 0;
+			nb = 5
+			v = 0
 		case '!' <= b && b <= 'u':
-			v = v*85 + uint32(b-'!');
-			nb++;
+			v = v*85 + uint32(b-'!')
+			nb++
 		default:
 			return 0, 0, CorruptInputError(i)
 		}
 		if nb == 5 {
-			nsrc = i + 1;
-			dst[ndst] = byte(v >> 24);
-			dst[ndst+1] = byte(v >> 16);
-			dst[ndst+2] = byte(v >> 8);
-			dst[ndst+3] = byte(v);
-			ndst += 4;
-			nb = 0;
-			v = 0;
+			nsrc = i + 1
+			dst[ndst] = byte(v >> 24)
+			dst[ndst+1] = byte(v >> 16)
+			dst[ndst+2] = byte(v >> 8)
+			dst[ndst+3] = byte(v)
+			ndst += 4
+			nb = 0
+			v = 0
 		}
 	}
 	if flush {
-		nsrc = len(src);
+		nsrc = len(src)
 		if nb > 0 {
 			// The number of output bytes in the last fragment
 			// is the number of leftover input bytes - 1:
@@ -233,27 +233,27 @@ func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
 				v = v*85 + 84
 			}
 			for i := 0; i < nb-1; i++ {
-				dst[ndst] = byte(v >> 24);
-				v <<= 8;
-				ndst++;
+				dst[ndst] = byte(v >> 24)
+				v <<= 8
+				ndst++
 			}
 		}
 	}
-	return;
+	return
 }
 
 // NewDecoder constructs a new ascii85 stream decoder.
-func NewDecoder(r io.Reader) io.Reader	{ return &decoder{r: r} }
+func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }
 
 type decoder struct {
-	err	os.Error;
-	readErr	os.Error;
-	r	io.Reader;
-	end	bool;		// saw end of message
-	buf	[1024]byte;	// leftover input
-	nbuf	int;
-	out	[]byte;	// leftover decoded output
-	outbuf	[1024]byte;
+	err     os.Error
+	readErr os.Error
+	r       io.Reader
+	end     bool       // saw end of message
+	buf     [1024]byte // leftover input
+	nbuf    int
+	out     []byte // leftover decoded output
+	outbuf  [1024]byte
 }
 
 func (d *decoder) Read(p []byte) (n int, err os.Error) {
@@ -267,19 +267,19 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 	for {
 		// Copy leftover output from last decode.
 		if len(d.out) > 0 {
-			n = copy(p, d.out);
-			d.out = d.out[n:];
-			return;
+			n = copy(p, d.out)
+			d.out = d.out[n:]
+			return
 		}
 
 		// Decode leftover input from last read.
-		var nn, nsrc, ndst int;
+		var nn, nsrc, ndst int
 		if d.nbuf > 0 {
-			ndst, nsrc, d.err = Decode(&d.outbuf, d.buf[0:d.nbuf], d.readErr != nil);
+			ndst, nsrc, d.err = Decode(&d.outbuf, d.buf[0:d.nbuf], d.readErr != nil)
 			if ndst > 0 {
-				d.out = d.outbuf[0:ndst];
-				d.nbuf = copy(&d.buf, d.buf[nsrc:d.nbuf]);
-				continue;	// copy out and return
+				d.out = d.outbuf[0:ndst]
+				d.nbuf = copy(&d.buf, d.buf[nsrc:d.nbuf])
+				continue // copy out and return
 			}
 		}
 
@@ -288,13 +288,13 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 			return 0, d.err
 		}
 		if d.readErr != nil {
-			d.err = d.readErr;
-			return 0, d.err;
+			d.err = d.readErr
+			return 0, d.err
 		}
 
 		// Read more data.
-		nn, d.readErr = d.r.Read(d.buf[d.nbuf:]);
-		d.nbuf += nn;
+		nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
+		d.nbuf += nn
 	}
-	panic("unreachable");
+	panic("unreachable")
 }
diff --git a/src/pkg/encoding/ascii85/ascii85_test.go b/src/pkg/encoding/ascii85/ascii85_test.go
index 5ac49c675c..7eb245ee26 100644
--- a/src/pkg/encoding/ascii85/ascii85_test.go
+++ b/src/pkg/encoding/ascii85/ascii85_test.go
@@ -5,16 +5,16 @@
 package ascii85
 
 import (
-	"bytes";
-	"io/ioutil";
-	"os";
-	"reflect";
-	"strings";
-	"testing";
+	"bytes"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 type testpair struct {
-	decoded, encoded string;
+	decoded, encoded string
 }
 
 var pairs = []testpair{
@@ -35,88 +35,88 @@ var pairs = []testpair{
 var bigtest = pairs[len(pairs)-1]
 
 func testEqual(t *testing.T, msg string, args ...) bool {
-	v := reflect.NewValue(args).(*reflect.StructValue);
-	v1 := v.Field(v.NumField() - 2);
-	v2 := v.Field(v.NumField() - 1);
+	v := reflect.NewValue(args).(*reflect.StructValue)
+	v1 := v.Field(v.NumField() - 2)
+	v2 := v.Field(v.NumField() - 1)
 	if v1.Interface() != v2.Interface() {
-		t.Errorf(msg, args);
-		return false;
+		t.Errorf(msg, args)
+		return false
 	}
-	return true;
+	return true
 }
 
 func strip85(s string) string {
-	t := make([]byte, len(s));
-	w := 0;
+	t := make([]byte, len(s))
+	w := 0
 	for r := 0; r < len(s); r++ {
-		c := s[r];
+		c := s[r]
 		if c > ' ' {
-			t[w] = c;
-			w++;
+			t[w] = c
+			w++
 		}
 	}
-	return string(t[0:w]);
+	return string(t[0:w])
 }
 
 func TestEncode(t *testing.T) {
 	for _, p := range pairs {
-		buf := make([]byte, MaxEncodedLen(len(p.decoded)));
-		n := Encode(buf, strings.Bytes(p.decoded));
-		buf = buf[0:n];
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded));
+		buf := make([]byte, MaxEncodedLen(len(p.decoded)))
+		n := Encode(buf, strings.Bytes(p.decoded))
+		buf = buf[0:n]
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded))
 	}
 }
 
 func TestEncoder(t *testing.T) {
 	for _, p := range pairs {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(bb);
-		encoder.Write(strings.Bytes(p.decoded));
-		encoder.Close();
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded));
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(bb)
+		encoder.Write(strings.Bytes(p.decoded))
+		encoder.Close()
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded))
 	}
 }
 
 func TestEncoderBuffering(t *testing.T) {
-	input := strings.Bytes(bigtest.decoded);
+	input := strings.Bytes(bigtest.decoded)
 	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(bb);
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(bb)
 		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs;
+			end := pos + bs
 			if end > len(input) {
 				end = len(input)
 			}
-			n, err := encoder.Write(input[pos:end]);
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil));
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos);
+			n, err := encoder.Write(input[pos:end])
+			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
+			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
 		}
-		err := encoder.Close();
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil));
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded));
+		err := encoder.Close()
+		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
+		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded))
 	}
 }
 
 func TestDecode(t *testing.T) {
 	for _, p := range pairs {
-		dbuf := make([]byte, 4*len(p.encoded));
-		ndst, nsrc, err := Decode(dbuf, strings.Bytes(p.encoded), true);
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil));
-		testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded));
-		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded));
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded);
+		dbuf := make([]byte, 4*len(p.encoded))
+		ndst, nsrc, err := Decode(dbuf, strings.Bytes(p.encoded), true)
+		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
+		testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded))
+		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
+		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
 	}
 }
 
 func TestDecoder(t *testing.T) {
 	for _, p := range pairs {
-		decoder := NewDecoder(bytes.NewBufferString(p.encoded));
-		dbuf, err := ioutil.ReadAll(decoder);
+		decoder := NewDecoder(bytes.NewBufferString(p.encoded))
+		dbuf, err := ioutil.ReadAll(decoder)
 		if err != nil {
 			t.Fatal("Read failed", err)
 		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded));
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded);
+		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
+		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
 		if err != nil {
 			testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
 		}
@@ -125,31 +125,31 @@ func TestDecoder(t *testing.T) {
 
 func TestDecoderBuffering(t *testing.T) {
 	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded));
-		buf := make([]byte, len(bigtest.decoded)+12);
-		var total int;
+		decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded))
+		buf := make([]byte, len(bigtest.decoded)+12)
+		var total int
 		for total = 0; total < len(bigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs]);
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil));
-			total += n;
+			n, err := decoder.Read(buf[total : total+bs])
+			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
+			total += n
 		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded);
+		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
 	}
 }
 
 func TestDecodeCorrupt(t *testing.T) {
 	type corrupt struct {
-		e	string;
-		p	int;
+		e string
+		p int
 	}
 	examples := []corrupt{
 		corrupt{"v", 0},
 		corrupt{"!z!!!!!!!!!", 1},
-	};
+	}
 
 	for _, e := range examples {
-		dbuf := make([]byte, 4*len(e.e));
-		_, _, err := Decode(dbuf, strings.Bytes(e.e), true);
+		dbuf := make([]byte, 4*len(e.e))
+		_, _, err := Decode(dbuf, strings.Bytes(e.e), true)
 		switch err := err.(type) {
 		case CorruptInputError:
 			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
@@ -160,34 +160,34 @@ func TestDecodeCorrupt(t *testing.T) {
 }
 
 func TestBig(t *testing.T) {
-	n := 3*1000 + 1;
-	raw := make([]byte, n);
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	n := 3*1000 + 1
+	raw := make([]byte, n)
+	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	for i := 0; i < n; i++ {
 		raw[i] = alpha[i%len(alpha)]
 	}
-	encoded := new(bytes.Buffer);
-	w := NewEncoder(encoded);
-	nn, err := w.Write(raw);
+	encoded := new(bytes.Buffer)
+	w := NewEncoder(encoded)
+	nn, err := w.Write(raw)
 	if nn != n || err != nil {
 		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
 	}
-	err = w.Close();
+	err = w.Close()
 	if err != nil {
 		t.Fatalf("Encoder.Close() = %v want nil", err)
 	}
-	decoded, err := ioutil.ReadAll(NewDecoder(encoded));
+	decoded, err := ioutil.ReadAll(NewDecoder(encoded))
 	if err != nil {
 		t.Fatalf("io.ReadAll(NewDecoder(...)): %v", err)
 	}
 
 	if !bytes.Equal(raw, decoded) {
-		var i int;
+		var i int
 		for i = 0; i < len(decoded) && i < len(raw); i++ {
 			if decoded[i] != raw[i] {
 				break
 			}
 		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i);
+		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
 	}
 }
diff --git a/src/pkg/encoding/base64/base64.go b/src/pkg/encoding/base64/base64.go
index e7b7f4da40..d4429094a2 100644
--- a/src/pkg/encoding/base64/base64.go
+++ b/src/pkg/encoding/base64/base64.go
@@ -6,9 +6,9 @@
 package base64
 
 import (
-	"io";
-	"os";
-	"strconv";
+	"io"
+	"os"
+	"strconv"
 )
 
 /*
@@ -21,8 +21,8 @@ import (
 // (RFC 1421).  RFC 4648 also defines an alternate encoding, which is
 // the standard encoding with - and _ substituted for + and /.
 type Encoding struct {
-	encode		string;
-	decodeMap	[256]byte;
+	encode    string
+	decodeMap [256]byte
 }
 
 const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
@@ -31,15 +31,15 @@ const encodeURL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678
 // NewEncoding returns a new Encoding defined by the given alphabet,
 // which must be a 64-byte string.
 func NewEncoding(encoder string) *Encoding {
-	e := new(Encoding);
-	e.encode = encoder;
+	e := new(Encoding)
+	e.encode = encoder
 	for i := 0; i < len(e.decodeMap); i++ {
 		e.decodeMap[i] = 0xFF
 	}
 	for i := 0; i < len(encoder); i++ {
 		e.decodeMap[encoder[i]] = byte(i)
 	}
-	return e;
+	return e
 }
 
 // StdEncoding is the standard base64 encoding, as defined in
@@ -66,25 +66,25 @@ func (enc *Encoding) Encode(dst, src []byte) {
 	}
 
 	for len(src) > 0 {
-		dst[0] = 0;
-		dst[1] = 0;
-		dst[2] = 0;
-		dst[3] = 0;
+		dst[0] = 0
+		dst[1] = 0
+		dst[2] = 0
+		dst[3] = 0
 
 		// Unpack 4x 6-bit source blocks into a 4 byte
 		// destination quantum
 		switch len(src) {
 		default:
-			dst[3] |= src[2] & 0x3F;
-			dst[2] |= src[2] >> 6;
-			fallthrough;
+			dst[3] |= src[2] & 0x3F
+			dst[2] |= src[2] >> 6
+			fallthrough
 		case 2:
-			dst[2] |= (src[1] << 2) & 0x3F;
-			dst[1] |= src[1] >> 4;
-			fallthrough;
+			dst[2] |= (src[1] << 2) & 0x3F
+			dst[1] |= src[1] >> 4
+			fallthrough
 		case 1:
-			dst[1] |= (src[0] << 4) & 0x3F;
-			dst[0] |= src[0] >> 2;
+			dst[1] |= (src[0] << 4) & 0x3F
+			dst[0] |= src[0] >> 2
 		}
 
 		// Encode 6-bit blocks using the base64 alphabet
@@ -94,25 +94,25 @@ func (enc *Encoding) Encode(dst, src []byte) {
 
 		// Pad the final quantum
 		if len(src) < 3 {
-			dst[3] = '=';
+			dst[3] = '='
 			if len(src) < 2 {
 				dst[2] = '='
 			}
-			break;
+			break
 		}
 
-		src = src[3:];
-		dst = dst[4:];
+		src = src[3:]
+		dst = dst[4:]
 	}
 }
 
 type encoder struct {
-	err	os.Error;
-	enc	*Encoding;
-	w	io.Writer;
-	buf	[3]byte;	// buffered data waiting to be encoded
-	nbuf	int;		// number of bytes in buf
-	out	[1024]byte;	// output buffer
+	err  os.Error
+	enc  *Encoding
+	w    io.Writer
+	buf  [3]byte    // buffered data waiting to be encoded
+	nbuf int        // number of bytes in buf
+	out  [1024]byte // output buffer
 }
 
 func (e *encoder) Write(p []byte) (n int, err os.Error) {
@@ -122,47 +122,47 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 
 	// Leading fringe.
 	if e.nbuf > 0 {
-		var i int;
+		var i int
 		for i = 0; i < len(p) && e.nbuf < 3; i++ {
-			e.buf[e.nbuf] = p[i];
-			e.nbuf++;
+			e.buf[e.nbuf] = p[i]
+			e.nbuf++
 		}
-		n += i;
-		p = p[i:];
+		n += i
+		p = p[i:]
 		if e.nbuf < 3 {
 			return
 		}
-		e.enc.Encode(&e.out, &e.buf);
+		e.enc.Encode(&e.out, &e.buf)
 		if _, e.err = e.w.Write(e.out[0:4]); e.err != nil {
 			return n, e.err
 		}
-		e.nbuf = 0;
+		e.nbuf = 0
 	}
 
 	// Large interior chunks.
 	for len(p) >= 3 {
-		nn := len(e.out) / 4 * 3;
+		nn := len(e.out) / 4 * 3
 		if nn > len(p) {
 			nn = len(p)
 		}
-		nn -= nn % 3;
+		nn -= nn % 3
 		if nn > 0 {
-			e.enc.Encode(&e.out, p[0:nn]);
+			e.enc.Encode(&e.out, p[0:nn])
 			if _, e.err = e.w.Write(e.out[0 : nn/3*4]); e.err != nil {
 				return n, e.err
 			}
 		}
-		n += nn;
-		p = p[nn:];
+		n += nn
+		p = p[nn:]
 	}
 
 	// Trailing fringe.
 	for i := 0; i < len(p); i++ {
 		e.buf[i] = p[i]
 	}
-	e.nbuf = len(p);
-	n += len(p);
-	return;
+	e.nbuf = len(p)
+	n += len(p)
+	return
 }
 
 // Close flushes any pending output from the encoder.
@@ -170,11 +170,11 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 func (e *encoder) Close() os.Error {
 	// If there's anything left in the buffer, flush it out
 	if e.err == nil && e.nbuf > 0 {
-		e.enc.Encode(&e.out, e.buf[0:e.nbuf]);
-		e.nbuf = 0;
-		_, e.err = e.w.Write(e.out[0:4]);
+		e.enc.Encode(&e.out, e.buf[0:e.nbuf])
+		e.nbuf = 0
+		_, e.err = e.w.Write(e.out[0:4])
 	}
-	return e.err;
+	return e.err
 }
 
 // NewEncoder returns a new base64 stream encoder.  Data written to
@@ -188,7 +188,7 @@ func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser {
 
 // EncodedLen returns the length in bytes of the base64 encoding
 // of an input buffer of length n.
-func (enc *Encoding) EncodedLen(n int) int	{ return (n + 2) / 3 * 4 }
+func (enc *Encoding) EncodedLen(n int) int { return (n + 2) / 3 * 4 }
 
 /*
  * Decoder
@@ -207,23 +207,23 @@ func (e CorruptInputError) String() string {
 func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err os.Error) {
 	for i := 0; i < len(src)/4 && !end; i++ {
 		// Decode quantum using the base64 alphabet
-		var dbuf [4]byte;
-		dlen := 4;
+		var dbuf [4]byte
+		dlen := 4
 
 	dbufloop:
 		for j := 0; j < 4; j++ {
-			in := src[i*4+j];
+			in := src[i*4+j]
 			if in == '=' && j >= 2 && i == len(src)/4-1 {
 				// We've reached the end and there's
 				// padding
 				if src[i*4+3] != '=' {
 					return n, false, CorruptInputError(i*4 + 2)
 				}
-				dlen = j;
-				end = true;
-				break dbufloop;
+				dlen = j
+				end = true
+				break dbufloop
 			}
-			dbuf[j] = enc.decodeMap[in];
+			dbuf[j] = enc.decodeMap[in]
 			if dbuf[j] == 0xFF {
 				return n, false, CorruptInputError(i*4 + j)
 			}
@@ -233,18 +233,18 @@ func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err os.Error) {
 		// quantum
 		switch dlen {
 		case 4:
-			dst[i*3+2] = dbuf[2]<<6 | dbuf[3];
-			fallthrough;
+			dst[i*3+2] = dbuf[2]<<6 | dbuf[3]
+			fallthrough
 		case 3:
-			dst[i*3+1] = dbuf[1]<<4 | dbuf[2]>>2;
-			fallthrough;
+			dst[i*3+1] = dbuf[1]<<4 | dbuf[2]>>2
+			fallthrough
 		case 2:
 			dst[i*3+0] = dbuf[0]<<2 | dbuf[1]>>4
 		}
-		n += dlen - 1;
+		n += dlen - 1
 	}
 
-	return n, end, nil;
+	return n, end, nil
 }
 
 // Decode decodes src using the encoding enc.  It writes at most
@@ -256,19 +256,19 @@ func (enc *Encoding) Decode(dst, src []byte) (n int, err os.Error) {
 		return 0, CorruptInputError(len(src) / 4 * 4)
 	}
 
-	n, _, err = enc.decode(dst, src);
-	return;
+	n, _, err = enc.decode(dst, src)
+	return
 }
 
 type decoder struct {
-	err	os.Error;
-	enc	*Encoding;
-	r	io.Reader;
-	end	bool;		// saw end of message
-	buf	[1024]byte;	// leftover input
-	nbuf	int;
-	out	[]byte;	// leftover decoded output
-	outbuf	[1024 / 4 * 3]byte;
+	err    os.Error
+	enc    *Encoding
+	r      io.Reader
+	end    bool       // saw end of message
+	buf    [1024]byte // leftover input
+	nbuf   int
+	out    []byte // leftover decoded output
+	outbuf [1024 / 4 * 3]byte
 }
 
 func (d *decoder) Read(p []byte) (n int, err os.Error) {
@@ -278,37 +278,37 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 
 	// Use leftover decoded output from last read.
 	if len(d.out) > 0 {
-		n = copy(p, d.out);
-		d.out = d.out[n:];
-		return n, nil;
+		n = copy(p, d.out)
+		d.out = d.out[n:]
+		return n, nil
 	}
 
 	// Read a chunk.
-	nn := len(p) / 3 * 4;
+	nn := len(p) / 3 * 4
 	if nn < 4 {
 		nn = 4
 	}
 	if nn > len(d.buf) {
 		nn = len(d.buf)
 	}
-	nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 4-d.nbuf);
-	d.nbuf += nn;
+	nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 4-d.nbuf)
+	d.nbuf += nn
 	if d.nbuf < 4 {
 		return 0, d.err
 	}
 
 	// Decode chunk into p, or d.out and then p if p is too small.
-	nr := d.nbuf / 4 * 4;
-	nw := d.nbuf / 4 * 3;
+	nr := d.nbuf / 4 * 4
+	nw := d.nbuf / 4 * 3
 	if nw > len(p) {
-		nw, d.end, d.err = d.enc.decode(&d.outbuf, d.buf[0:nr]);
-		d.out = d.outbuf[0:nw];
-		n = copy(p, d.out);
-		d.out = d.out[n:];
+		nw, d.end, d.err = d.enc.decode(&d.outbuf, d.buf[0:nr])
+		d.out = d.outbuf[0:nw]
+		n = copy(p, d.out)
+		d.out = d.out[n:]
 	} else {
 		n, d.end, d.err = d.enc.decode(p, d.buf[0:nr])
 	}
-	d.nbuf -= nr;
+	d.nbuf -= nr
 	for i := 0; i < d.nbuf; i++ {
 		d.buf[i] = d.buf[i+nr]
 	}
@@ -316,7 +316,7 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 	if d.err == nil {
 		d.err = err
 	}
-	return n, d.err;
+	return n, d.err
 }
 
 // NewDecoder constructs a new base64 stream decoder.
@@ -326,4 +326,4 @@ func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
 
 // DecodeLen returns the maximum length in bytes of the decoded data
 // corresponding to n bytes of base64-encoded data.
-func (enc *Encoding) DecodedLen(n int) int	{ return n / 4 * 3 }
+func (enc *Encoding) DecodedLen(n int) int { return n / 4 * 3 }
diff --git a/src/pkg/encoding/base64/base64_test.go b/src/pkg/encoding/base64/base64_test.go
index 3153a73470..fe66cff7e6 100644
--- a/src/pkg/encoding/base64/base64_test.go
+++ b/src/pkg/encoding/base64/base64_test.go
@@ -5,16 +5,16 @@
 package base64
 
 import (
-	"bytes";
-	"io/ioutil";
-	"os";
-	"reflect";
-	"strings";
-	"testing";
+	"bytes"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 type testpair struct {
-	decoded, encoded string;
+	decoded, encoded string
 }
 
 var pairs = []testpair{
@@ -49,102 +49,102 @@ var bigtest = testpair{
 }
 
 func testEqual(t *testing.T, msg string, args ...) bool {
-	v := reflect.NewValue(args).(*reflect.StructValue);
-	v1 := v.Field(v.NumField() - 2);
-	v2 := v.Field(v.NumField() - 1);
+	v := reflect.NewValue(args).(*reflect.StructValue)
+	v1 := v.Field(v.NumField() - 2)
+	v2 := v.Field(v.NumField() - 1)
 	if v1.Interface() != v2.Interface() {
-		t.Errorf(msg, args);
-		return false;
+		t.Errorf(msg, args)
+		return false
 	}
-	return true;
+	return true
 }
 
 func TestEncode(t *testing.T) {
 	for _, p := range pairs {
-		buf := make([]byte, StdEncoding.EncodedLen(len(p.decoded)));
-		StdEncoding.Encode(buf, strings.Bytes(p.decoded));
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded);
+		buf := make([]byte, StdEncoding.EncodedLen(len(p.decoded)))
+		StdEncoding.Encode(buf, strings.Bytes(p.decoded))
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded)
 	}
 }
 
 func TestEncoder(t *testing.T) {
 	for _, p := range pairs {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(StdEncoding, bb);
-		encoder.Write(strings.Bytes(p.decoded));
-		encoder.Close();
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded);
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(StdEncoding, bb)
+		encoder.Write(strings.Bytes(p.decoded))
+		encoder.Close()
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
 	}
 }
 
 func TestEncoderBuffering(t *testing.T) {
-	input := strings.Bytes(bigtest.decoded);
+	input := strings.Bytes(bigtest.decoded)
 	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(StdEncoding, bb);
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(StdEncoding, bb)
 		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs;
+			end := pos + bs
 			if end > len(input) {
 				end = len(input)
 			}
-			n, err := encoder.Write(input[pos:end]);
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil));
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos);
+			n, err := encoder.Write(input[pos:end])
+			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
+			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
 		}
-		err := encoder.Close();
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil));
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded);
+		err := encoder.Close()
+		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
+		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded)
 	}
 }
 
 func TestDecode(t *testing.T) {
 	for _, p := range pairs {
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)));
-		count, end, err := StdEncoding.decode(dbuf, strings.Bytes(p.encoded));
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil));
-		testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded));
+		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
+		count, end, err := StdEncoding.decode(dbuf, strings.Bytes(p.encoded))
+		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
+		testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded))
 		if len(p.encoded) > 0 {
 			testEqual(t, "Decode(%q) = end %v, want %v", p.encoded, end, (p.encoded[len(p.encoded)-1] == '='))
 		}
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded);
+		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
 	}
 }
 
 func TestDecoder(t *testing.T) {
 	for _, p := range pairs {
-		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(p.encoded));
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)));
-		count, err := decoder.Read(dbuf);
+		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(p.encoded))
+		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
+		count, err := decoder.Read(dbuf)
 		if err != nil && err != os.EOF {
 			t.Fatal("Read failed", err)
 		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded));
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded);
+		testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded))
+		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
 		if err != os.EOF {
 			count, err = decoder.Read(dbuf)
 		}
-		testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF);
+		testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
 	}
 }
 
 func TestDecoderBuffering(t *testing.T) {
 	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded));
-		buf := make([]byte, len(bigtest.decoded)+12);
-		var total int;
+		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded))
+		buf := make([]byte, len(bigtest.decoded)+12)
+		var total int
 		for total = 0; total < len(bigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs]);
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil));
-			total += n;
+			n, err := decoder.Read(buf[total : total+bs])
+			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
+			total += n
 		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded);
+		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
 	}
 }
 
 func TestDecodeCorrupt(t *testing.T) {
 	type corrupt struct {
-		e	string;
-		p	int;
+		e string
+		p int
 	}
 	examples := []corrupt{
 		corrupt{"!!!!", 0},
@@ -153,11 +153,11 @@ func TestDecodeCorrupt(t *testing.T) {
 		corrupt{"AAA=AAAA", 3},
 		corrupt{"AAAAA", 4},
 		corrupt{"AAAAAA", 4},
-	};
+	}
 
 	for _, e := range examples {
-		dbuf := make([]byte, StdEncoding.DecodedLen(len(e.e)));
-		_, err := StdEncoding.Decode(dbuf, strings.Bytes(e.e));
+		dbuf := make([]byte, StdEncoding.DecodedLen(len(e.e)))
+		_, err := StdEncoding.Decode(dbuf, strings.Bytes(e.e))
 		switch err := err.(type) {
 		case CorruptInputError:
 			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
@@ -168,34 +168,34 @@ func TestDecodeCorrupt(t *testing.T) {
 }
 
 func TestBig(t *testing.T) {
-	n := 3*1000 + 1;
-	raw := make([]byte, n);
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	n := 3*1000 + 1
+	raw := make([]byte, n)
+	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	for i := 0; i < n; i++ {
 		raw[i] = alpha[i%len(alpha)]
 	}
-	encoded := new(bytes.Buffer);
-	w := NewEncoder(StdEncoding, encoded);
-	nn, err := w.Write(raw);
+	encoded := new(bytes.Buffer)
+	w := NewEncoder(StdEncoding, encoded)
+	nn, err := w.Write(raw)
 	if nn != n || err != nil {
 		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
 	}
-	err = w.Close();
+	err = w.Close()
 	if err != nil {
 		t.Fatalf("Encoder.Close() = %v want nil", err)
 	}
-	decoded, err := ioutil.ReadAll(NewDecoder(StdEncoding, encoded));
+	decoded, err := ioutil.ReadAll(NewDecoder(StdEncoding, encoded))
 	if err != nil {
 		t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err)
 	}
 
 	if !bytes.Equal(raw, decoded) {
-		var i int;
+		var i int
 		for i = 0; i < len(decoded) && i < len(raw); i++ {
 			if decoded[i] != raw[i] {
 				break
 			}
 		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i);
+		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
 	}
 }
diff --git a/src/pkg/encoding/binary/binary.go b/src/pkg/encoding/binary/binary.go
index 419ec03a51..36f2366d64 100644
--- a/src/pkg/encoding/binary/binary.go
+++ b/src/pkg/encoding/binary/binary.go
@@ -7,22 +7,22 @@
 package binary
 
 import (
-	"math";
-	"io";
-	"os";
-	"reflect";
+	"math"
+	"io"
+	"os"
+	"reflect"
 )
 
 // A ByteOrder specifies how to convert byte sequences into
 // 16-, 32-, or 64-bit unsigned integers.
 type ByteOrder interface {
-	Uint16(b []byte) uint16;
-	Uint32(b []byte) uint32;
-	Uint64(b []byte) uint64;
-	PutUint16([]byte, uint16);
-	PutUint32([]byte, uint32);
-	PutUint64([]byte, uint64);
-	String() string;
+	Uint16(b []byte) uint16
+	Uint32(b []byte) uint32
+	Uint64(b []byte) uint64
+	PutUint16([]byte, uint16)
+	PutUint32([]byte, uint32)
+	PutUint64([]byte, uint64)
+	String() string
 }
 
 // This is byte instead of struct{} so that it can be compared,
@@ -34,11 +34,11 @@ var BigEndian ByteOrder = bigEndian(0)
 
 type littleEndian unused
 
-func (littleEndian) Uint16(b []byte) uint16	{ return uint16(b[0]) | uint16(b[1])<<8 }
+func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 }
 
 func (littleEndian) PutUint16(b []byte, v uint16) {
-	b[0] = byte(v);
-	b[1] = byte(v >> 8);
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
 }
 
 func (littleEndian) Uint32(b []byte) uint32 {
@@ -46,10 +46,10 @@ func (littleEndian) Uint32(b []byte) uint32 {
 }
 
 func (littleEndian) PutUint32(b []byte, v uint32) {
-	b[0] = byte(v);
-	b[1] = byte(v >> 8);
-	b[2] = byte(v >> 16);
-	b[3] = byte(v >> 24);
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
 }
 
 func (littleEndian) Uint64(b []byte) uint64 {
@@ -58,27 +58,27 @@ func (littleEndian) Uint64(b []byte) uint64 {
 }
 
 func (littleEndian) PutUint64(b []byte, v uint64) {
-	b[0] = byte(v);
-	b[1] = byte(v >> 8);
-	b[2] = byte(v >> 16);
-	b[3] = byte(v >> 24);
-	b[4] = byte(v >> 32);
-	b[5] = byte(v >> 40);
-	b[6] = byte(v >> 48);
-	b[7] = byte(v >> 56);
+	b[0] = byte(v)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v >> 16)
+	b[3] = byte(v >> 24)
+	b[4] = byte(v >> 32)
+	b[5] = byte(v >> 40)
+	b[6] = byte(v >> 48)
+	b[7] = byte(v >> 56)
 }
 
-func (littleEndian) String() string	{ return "LittleEndian" }
+func (littleEndian) String() string { return "LittleEndian" }
 
-func (littleEndian) GoString() string	{ return "binary.LittleEndian" }
+func (littleEndian) GoString() string { return "binary.LittleEndian" }
 
 type bigEndian unused
 
-func (bigEndian) Uint16(b []byte) uint16	{ return uint16(b[1]) | uint16(b[0])<<8 }
+func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 }
 
 func (bigEndian) PutUint16(b []byte, v uint16) {
-	b[0] = byte(v >> 8);
-	b[1] = byte(v);
+	b[0] = byte(v >> 8)
+	b[1] = byte(v)
 }
 
 func (bigEndian) Uint32(b []byte) uint32 {
@@ -86,10 +86,10 @@ func (bigEndian) Uint32(b []byte) uint32 {
 }
 
 func (bigEndian) PutUint32(b []byte, v uint32) {
-	b[0] = byte(v >> 24);
-	b[1] = byte(v >> 16);
-	b[2] = byte(v >> 8);
-	b[3] = byte(v);
+	b[0] = byte(v >> 24)
+	b[1] = byte(v >> 16)
+	b[2] = byte(v >> 8)
+	b[3] = byte(v)
 }
 
 func (bigEndian) Uint64(b []byte) uint64 {
@@ -98,19 +98,19 @@ func (bigEndian) Uint64(b []byte) uint64 {
 }
 
 func (bigEndian) PutUint64(b []byte, v uint64) {
-	b[0] = byte(v >> 56);
-	b[1] = byte(v >> 48);
-	b[2] = byte(v >> 40);
-	b[3] = byte(v >> 32);
-	b[4] = byte(v >> 24);
-	b[5] = byte(v >> 16);
-	b[6] = byte(v >> 8);
-	b[7] = byte(v);
+	b[0] = byte(v >> 56)
+	b[1] = byte(v >> 48)
+	b[2] = byte(v >> 40)
+	b[3] = byte(v >> 32)
+	b[4] = byte(v >> 24)
+	b[5] = byte(v >> 16)
+	b[6] = byte(v >> 8)
+	b[7] = byte(v)
 }
 
-func (bigEndian) String() string	{ return "BigEndian" }
+func (bigEndian) String() string { return "BigEndian" }
 
-func (bigEndian) GoString() string	{ return "binary.BigEndian" }
+func (bigEndian) GoString() string { return "binary.BigEndian" }
 
 // Read reads structured binary data from r into data.
 // Data must be a pointer to a fixed-size value or a slice
@@ -121,7 +121,7 @@ func (bigEndian) GoString() string	{ return "binary.BigEndian" }
 // r are decoded using the specified byte order and written
 // to successive fields of the data.
 func Read(r io.Reader, order ByteOrder, data interface{}) os.Error {
-	var v reflect.Value;
+	var v reflect.Value
 	switch d := reflect.NewValue(data).(type) {
 	case *reflect.PtrValue:
 		v = d.Elem()
@@ -130,16 +130,16 @@ func Read(r io.Reader, order ByteOrder, data interface{}) os.Error {
 	default:
 		return os.NewError("binary.Read: invalid type " + v.Type().String())
 	}
-	size := TotalSize(v);
+	size := TotalSize(v)
 	if size < 0 {
 		return os.NewError("binary.Read: invalid type " + v.Type().String())
 	}
-	d := &decoder{order: order, buf: make([]byte, size)};
+	d := &decoder{order: order, buf: make([]byte, size)}
 	if _, err := io.ReadFull(r, d.buf); err != nil {
 		return err
 	}
-	d.value(v);
-	return nil;
+	d.value(v)
+	return nil
 }
 
 // Write writes the binary representation of data into w.
@@ -151,48 +151,48 @@ func Read(r io.Reader, order ByteOrder, data interface{}) os.Error {
 // w are encoded using the specified byte order and read
 // from successive fields of the data.
 func Write(w io.Writer, order ByteOrder, data interface{}) os.Error {
-	v := reflect.Indirect(reflect.NewValue(data));
-	size := TotalSize(v);
+	v := reflect.Indirect(reflect.NewValue(data))
+	size := TotalSize(v)
 	if size < 0 {
 		return os.NewError("binary.Write: invalid type " + v.Type().String())
 	}
-	buf := make([]byte, size);
-	e := &encoder{order: order, buf: buf};
-	e.value(v);
-	_, err := w.Write(buf);
-	return err;
+	buf := make([]byte, size)
+	e := &encoder{order: order, buf: buf}
+	e.value(v)
+	_, err := w.Write(buf)
+	return err
 }
 
 func TotalSize(v reflect.Value) int {
 	if sv, ok := v.(*reflect.SliceValue); ok {
-		elem := sizeof(v.Type().(*reflect.SliceType).Elem());
+		elem := sizeof(v.Type().(*reflect.SliceType).Elem())
 		if elem < 0 {
 			return -1
 		}
-		return sv.Len() * elem;
+		return sv.Len() * elem
 	}
-	return sizeof(v.Type());
+	return sizeof(v.Type())
 }
 
 func sizeof(v reflect.Type) int {
 	switch t := v.(type) {
 	case *reflect.ArrayType:
-		n := sizeof(t.Elem());
+		n := sizeof(t.Elem())
 		if n < 0 {
 			return -1
 		}
-		return t.Len() * n;
+		return t.Len() * n
 
 	case *reflect.StructType:
-		sum := 0;
+		sum := 0
 		for i, n := 0, t.NumField(); i < n; i++ {
-			s := sizeof(t.Field(i).Type);
+			s := sizeof(t.Field(i).Type)
 			if s < 0 {
 				return -1
 			}
-			sum += s;
+			sum += s
 		}
-		return sum;
+		return sum
 
 	case *reflect.Uint8Type:
 		return 1
@@ -215,94 +215,94 @@ func sizeof(v reflect.Type) int {
 	case *reflect.Float64Type:
 		return 8
 	}
-	return -1;
+	return -1
 }
 
 type decoder struct {
-	order	ByteOrder;
-	buf	[]byte;
+	order ByteOrder
+	buf   []byte
 }
 
 type encoder struct {
-	order	ByteOrder;
-	buf	[]byte;
+	order ByteOrder
+	buf   []byte
 }
 
 func (d *decoder) uint8() uint8 {
-	x := d.buf[0];
-	d.buf = d.buf[1:];
-	return x;
+	x := d.buf[0]
+	d.buf = d.buf[1:]
+	return x
 }
 
 func (e *encoder) uint8(x uint8) {
-	e.buf[0] = x;
-	e.buf = e.buf[1:];
+	e.buf[0] = x
+	e.buf = e.buf[1:]
 }
 
 func (d *decoder) uint16() uint16 {
-	x := d.order.Uint16(d.buf[0:2]);
-	d.buf = d.buf[2:];
-	return x;
+	x := d.order.Uint16(d.buf[0:2])
+	d.buf = d.buf[2:]
+	return x
 }
 
 func (e *encoder) uint16(x uint16) {
-	e.order.PutUint16(e.buf[0:2], x);
-	e.buf = e.buf[2:];
+	e.order.PutUint16(e.buf[0:2], x)
+	e.buf = e.buf[2:]
 }
 
 func (d *decoder) uint32() uint32 {
-	x := d.order.Uint32(d.buf[0:4]);
-	d.buf = d.buf[4:];
-	return x;
+	x := d.order.Uint32(d.buf[0:4])
+	d.buf = d.buf[4:]
+	return x
 }
 
 func (e *encoder) uint32(x uint32) {
-	e.order.PutUint32(e.buf[0:4], x);
-	e.buf = e.buf[4:];
+	e.order.PutUint32(e.buf[0:4], x)
+	e.buf = e.buf[4:]
 }
 
 func (d *decoder) uint64() uint64 {
-	x := d.order.Uint64(d.buf[0:8]);
-	d.buf = d.buf[8:];
-	return x;
+	x := d.order.Uint64(d.buf[0:8])
+	d.buf = d.buf[8:]
+	return x
 }
 
 func (e *encoder) uint64(x uint64) {
-	e.order.PutUint64(e.buf[0:8], x);
-	e.buf = e.buf[8:];
+	e.order.PutUint64(e.buf[0:8], x)
+	e.buf = e.buf[8:]
 }
 
-func (d *decoder) int8() int8	{ return int8(d.uint8()) }
+func (d *decoder) int8() int8 { return int8(d.uint8()) }
 
-func (e *encoder) int8(x int8)	{ e.uint8(uint8(x)) }
+func (e *encoder) int8(x int8) { e.uint8(uint8(x)) }
 
-func (d *decoder) int16() int16	{ return int16(d.uint16()) }
+func (d *decoder) int16() int16 { return int16(d.uint16()) }
 
-func (e *encoder) int16(x int16)	{ e.uint16(uint16(x)) }
+func (e *encoder) int16(x int16) { e.uint16(uint16(x)) }
 
-func (d *decoder) int32() int32	{ return int32(d.uint32()) }
+func (d *decoder) int32() int32 { return int32(d.uint32()) }
 
-func (e *encoder) int32(x int32)	{ e.uint32(uint32(x)) }
+func (e *encoder) int32(x int32) { e.uint32(uint32(x)) }
 
-func (d *decoder) int64() int64	{ return int64(d.uint64()) }
+func (d *decoder) int64() int64 { return int64(d.uint64()) }
 
-func (e *encoder) int64(x int64)	{ e.uint64(uint64(x)) }
+func (e *encoder) int64(x int64) { e.uint64(uint64(x)) }
 
 func (d *decoder) value(v reflect.Value) {
 	switch v := v.(type) {
 	case *reflect.ArrayValue:
-		l := v.Len();
+		l := v.Len()
 		for i := 0; i < l; i++ {
 			d.value(v.Elem(i))
 		}
 	case *reflect.StructValue:
-		l := v.NumField();
+		l := v.NumField()
 		for i := 0; i < l; i++ {
 			d.value(v.Field(i))
 		}
 
 	case *reflect.SliceValue:
-		l := v.Len();
+		l := v.Len()
 		for i := 0; i < l; i++ {
 			d.value(v.Elem(i))
 		}
@@ -333,17 +333,17 @@ func (d *decoder) value(v reflect.Value) {
 func (e *encoder) value(v reflect.Value) {
 	switch v := v.(type) {
 	case *reflect.ArrayValue:
-		l := v.Len();
+		l := v.Len()
 		for i := 0; i < l; i++ {
 			e.value(v.Elem(i))
 		}
 	case *reflect.StructValue:
-		l := v.NumField();
+		l := v.NumField()
 		for i := 0; i < l; i++ {
 			e.value(v.Field(i))
 		}
 	case *reflect.SliceValue:
-		l := v.Len();
+		l := v.Len()
 		for i := 0; i < l; i++ {
 			e.value(v.Elem(i))
 		}
diff --git a/src/pkg/encoding/binary/binary_test.go b/src/pkg/encoding/binary/binary_test.go
index 33e6b0bea6..12d192d1ed 100644
--- a/src/pkg/encoding/binary/binary_test.go
+++ b/src/pkg/encoding/binary/binary_test.go
@@ -5,24 +5,24 @@
 package binary
 
 import (
-	"os";
-	"bytes";
-	"math";
-	"reflect";
-	"testing";
+	"os"
+	"bytes"
+	"math"
+	"reflect"
+	"testing"
 )
 
 type Struct struct {
-	Int8	int8;
-	Int16	int16;
-	Int32	int32;
-	Int64	int64;
-	Uint8	uint8;
-	Uint16	uint16;
-	Uint32	uint32;
-	Uint64	uint64;
-	Float64	float64;
-	Array	[4]uint8;
+	Int8    int8
+	Int16   int16
+	Int32   int32
+	Int64   int64
+	Uint8   uint8
+	Uint16  uint16
+	Uint32  uint32
+	Uint64  uint64
+	Float64 float64
+	Array   [4]uint8
 }
 
 var s = Struct{
@@ -69,8 +69,8 @@ var res = []int32{0x01020304, 0x05060708}
 
 func checkResult(t *testing.T, dir string, order, err os.Error, have, want interface{}) {
 	if err != nil {
-		t.Errorf("%v %v: %v", dir, order, err);
-		return;
+		t.Errorf("%v %v: %v", dir, order, err)
+		return
 	}
 	if !reflect.DeepEqual(have, want) {
 		t.Errorf("%v %v:\n\thave %+v\n\twant %+v", dir, order, have, want)
@@ -78,37 +78,37 @@ func checkResult(t *testing.T, dir string, order, err os.Error, have, want inter
 }
 
 func testRead(t *testing.T, order ByteOrder, b []byte, s1 interface{}) {
-	var s2 Struct;
-	err := Read(bytes.NewBuffer(b), order, &s2);
-	checkResult(t, "Read", order, err, s2, s1);
+	var s2 Struct
+	err := Read(bytes.NewBuffer(b), order, &s2)
+	checkResult(t, "Read", order, err, s2, s1)
 }
 
 func testWrite(t *testing.T, order ByteOrder, b []byte, s1 interface{}) {
-	buf := new(bytes.Buffer);
-	err := Write(buf, order, s1);
-	checkResult(t, "Write", order, err, buf.Bytes(), b);
+	buf := new(bytes.Buffer)
+	err := Write(buf, order, s1)
+	checkResult(t, "Write", order, err, buf.Bytes(), b)
 }
 
-func TestBigEndianRead(t *testing.T)	{ testRead(t, BigEndian, big, s) }
+func TestBigEndianRead(t *testing.T) { testRead(t, BigEndian, big, s) }
 
-func TestLittleEndianRead(t *testing.T)	{ testRead(t, LittleEndian, little, s) }
+func TestLittleEndianRead(t *testing.T) { testRead(t, LittleEndian, little, s) }
 
-func TestBigEndianWrite(t *testing.T)	{ testWrite(t, BigEndian, big, s) }
+func TestBigEndianWrite(t *testing.T) { testWrite(t, BigEndian, big, s) }
 
-func TestLittleEndianWrite(t *testing.T)	{ testWrite(t, LittleEndian, little, s) }
+func TestLittleEndianWrite(t *testing.T) { testWrite(t, LittleEndian, little, s) }
 
-func TestBigEndianPtrWrite(t *testing.T)	{ testWrite(t, BigEndian, big, &s) }
+func TestBigEndianPtrWrite(t *testing.T) { testWrite(t, BigEndian, big, &s) }
 
-func TestLittleEndianPtrWrite(t *testing.T)	{ testWrite(t, LittleEndian, little, &s) }
+func TestLittleEndianPtrWrite(t *testing.T) { testWrite(t, LittleEndian, little, &s) }
 
 func TestReadSlice(t *testing.T) {
-	slice := make([]int32, 2);
-	err := Read(bytes.NewBuffer(src), BigEndian, slice);
-	checkResult(t, "ReadSlice", BigEndian, err, slice, res);
+	slice := make([]int32, 2)
+	err := Read(bytes.NewBuffer(src), BigEndian, slice)
+	checkResult(t, "ReadSlice", BigEndian, err, slice, res)
 }
 
 func TestWriteSlice(t *testing.T) {
-	buf := new(bytes.Buffer);
-	err := Write(buf, BigEndian, res);
-	checkResult(t, "WriteSlice", BigEndian, err, buf.Bytes(), src);
+	buf := new(bytes.Buffer)
+	err := Write(buf, BigEndian, res)
+	checkResult(t, "WriteSlice", BigEndian, err, buf.Bytes(), src)
 }
diff --git a/src/pkg/encoding/git85/git.go b/src/pkg/encoding/git85/git.go
index 1e52997929..25a3deac00 100644
--- a/src/pkg/encoding/git85/git.go
+++ b/src/pkg/encoding/git85/git.go
@@ -7,10 +7,10 @@
 package git85
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"strconv";
+	"bytes"
+	"io"
+	"os"
+	"strconv"
 )
 
 type CorruptInputError int64
@@ -49,9 +49,9 @@ var decode = [256]uint8{
 // The encoding splits src into chunks of at most 52 bytes
 // and encodes each chunk on its own line.
 func Encode(dst, src []byte) int {
-	ndst := 0;
+	ndst := 0
 	for len(src) > 0 {
-		n := len(src);
+		n := len(src)
 		if n > 52 {
 			n = 52
 		}
@@ -60,23 +60,23 @@ func Encode(dst, src []byte) int {
 		} else {
 			dst[ndst] = byte('a' + n - 26 - 1)
 		}
-		ndst++;
+		ndst++
 		for i := 0; i < n; i += 4 {
-			var v uint32;
+			var v uint32
 			for j := 0; j < 4 && i+j < n; j++ {
 				v |= uint32(src[i+j]) << uint(24-j*8)
 			}
 			for j := 4; j >= 0; j-- {
-				dst[ndst+j] = encode[v%85];
-				v /= 85;
+				dst[ndst+j] = encode[v%85]
+				v /= 85
 			}
-			ndst += 5;
+			ndst += 5
 		}
-		dst[ndst] = '\n';
-		ndst++;
-		src = src[n:];
+		dst[ndst] = '\n'
+		ndst++
+		src = src[n:]
 	}
-	return ndst;
+	return ndst
 }
 
 // EncodedLen returns the length of an encoding of n source bytes.
@@ -86,7 +86,7 @@ func EncodedLen(n int) int {
 	}
 	// 5 bytes per 4 bytes of input, rounded up.
 	// 2 extra bytes for each line of 52 src bytes, rounded up.
-	return (n+3)/4*5 + (n+51)/52*2;
+	return (n+3)/4*5 + (n+51)/52*2
 }
 
 var newline = []byte{'\n'}
@@ -97,10 +97,10 @@ var newline = []byte{'\n'}
 // If Decode encounters invalid input, it returns a CorruptInputError.
 //
 func Decode(dst, src []byte) (n int, err os.Error) {
-	ndst := 0;
-	nsrc := 0;
+	ndst := 0
+	nsrc := 0
 	for nsrc < len(src) {
-		var l int;
+		var l int
 		switch ch := int(src[nsrc]); {
 		case 'A' <= ch && ch <= 'Z':
 			l = ch - 'A' + 1
@@ -112,24 +112,24 @@ func Decode(dst, src []byte) (n int, err os.Error) {
 		if nsrc+1+l > len(src) {
 			return ndst, CorruptInputError(nsrc)
 		}
-		el := (l + 3) / 4 * 5;	// encoded len
+		el := (l + 3) / 4 * 5 // encoded len
 		if nsrc+1+el+1 > len(src) || src[nsrc+1+el] != '\n' {
 			return ndst, CorruptInputError(nsrc)
 		}
-		line := src[nsrc+1 : nsrc+1+el];
+		line := src[nsrc+1 : nsrc+1+el]
 		for i := 0; i < el; i += 5 {
-			var v uint32;
+			var v uint32
 			for j := 0; j < 5; j++ {
-				ch := decode[line[i+j]];
+				ch := decode[line[i+j]]
 				if ch == 0 {
 					return ndst, CorruptInputError(nsrc + 1 + i + j)
 				}
-				v = v*85 + uint32(ch-1);
+				v = v*85 + uint32(ch-1)
 			}
 			for j := 0; j < 4; j++ {
-				dst[ndst] = byte(v >> 24);
-				v <<= 8;
-				ndst++;
+				dst[ndst] = byte(v >> 24)
+				v <<= 8
+				ndst++
 			}
 		}
 		// Last fragment may have run too far (but there was room in dst).
@@ -137,27 +137,27 @@ func Decode(dst, src []byte) (n int, err os.Error) {
 		if l%4 != 0 {
 			ndst -= 4 - l%4
 		}
-		nsrc += 1 + el + 1;
+		nsrc += 1 + el + 1
 	}
-	return ndst, nil;
+	return ndst, nil
 }
 
-func MaxDecodedLen(n int) int	{ return n / 5 * 4 }
+func MaxDecodedLen(n int) int { return n / 5 * 4 }
 
 // NewEncoder returns a new Git base85 stream encoder.  Data written to
 // the returned writer will be encoded and then written to w.
 // The Git encoding operates on 52-byte blocks; when finished
 // writing, the caller must Close the returned encoder to flush any
 // partially written blocks.
-func NewEncoder(w io.Writer) io.WriteCloser	{ return &encoder{w: w} }
+func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} }
 
 type encoder struct {
-	w	io.Writer;
-	err	os.Error;
-	buf	[52]byte;
-	nbuf	int;
-	out	[1024]byte;
-	nout	int;
+	w    io.Writer
+	err  os.Error
+	buf  [52]byte
+	nbuf int
+	out  [1024]byte
+	nout int
 }
 
 func (e *encoder) Write(p []byte) (n int, err os.Error) {
@@ -167,70 +167,70 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 
 	// Leading fringe.
 	if e.nbuf > 0 {
-		var i int;
+		var i int
 		for i = 0; i < len(p) && e.nbuf < 52; i++ {
-			e.buf[e.nbuf] = p[i];
-			e.nbuf++;
+			e.buf[e.nbuf] = p[i]
+			e.nbuf++
 		}
-		n += i;
-		p = p[i:];
+		n += i
+		p = p[i:]
 		if e.nbuf < 52 {
 			return
 		}
-		nout := Encode(&e.out, &e.buf);
+		nout := Encode(&e.out, &e.buf)
 		if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
 			return n, e.err
 		}
-		e.nbuf = 0;
+		e.nbuf = 0
 	}
 
 	// Large interior chunks.
 	for len(p) >= 52 {
-		nn := len(e.out) / (1 + 52/4*5 + 1) * 52;
+		nn := len(e.out) / (1 + 52/4*5 + 1) * 52
 		if nn > len(p) {
 			nn = len(p) / 52 * 52
 		}
 		if nn > 0 {
-			nout := Encode(&e.out, p[0:nn]);
+			nout := Encode(&e.out, p[0:nn])
 			if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
 				return n, e.err
 			}
 		}
-		n += nn;
-		p = p[nn:];
+		n += nn
+		p = p[nn:]
 	}
 
 	// Trailing fringe.
 	for i := 0; i < len(p); i++ {
 		e.buf[i] = p[i]
 	}
-	e.nbuf = len(p);
-	n += len(p);
-	return;
+	e.nbuf = len(p)
+	n += len(p)
+	return
 }
 
 func (e *encoder) Close() os.Error {
 	// If there's anything left in the buffer, flush it out
 	if e.err == nil && e.nbuf > 0 {
-		nout := Encode(&e.out, e.buf[0:e.nbuf]);
-		e.nbuf = 0;
-		_, e.err = e.w.Write(e.out[0:nout]);
+		nout := Encode(&e.out, e.buf[0:e.nbuf])
+		e.nbuf = 0
+		_, e.err = e.w.Write(e.out[0:nout])
 	}
-	return e.err;
+	return e.err
 }
 
 // NewDecoder returns a new Git base85 stream decoder.
-func NewDecoder(r io.Reader) io.Reader	{ return &decoder{r: r} }
+func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }
 
 type decoder struct {
-	r	io.Reader;
-	err	os.Error;
-	readErr	os.Error;
-	buf	[1024]byte;
-	nbuf	int;
-	out	[]byte;
-	outbuf	[1024]byte;
-	off	int64;
+	r       io.Reader
+	err     os.Error
+	readErr os.Error
+	buf     [1024]byte
+	nbuf    int
+	out     []byte
+	outbuf  [1024]byte
+	off     int64
 }
 
 func (d *decoder) Read(p []byte) (n int, err os.Error) {
@@ -241,9 +241,9 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 	for {
 		// Copy leftover output from last decode.
 		if len(d.out) > 0 {
-			n = copy(p, d.out);
-			d.out = d.out[n:];
-			return;
+			n = copy(p, d.out)
+			d.out = d.out[n:]
+			return
 		}
 
 		// Out of decoded output.  Check errors.
@@ -251,27 +251,27 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 			return 0, d.err
 		}
 		if d.readErr != nil {
-			d.err = d.readErr;
-			return 0, d.err;
+			d.err = d.readErr
+			return 0, d.err
 		}
 
 		// Read and decode more input.
-		var nn int;
-		nn, d.readErr = d.r.Read(d.buf[d.nbuf:]);
-		d.nbuf += nn;
+		var nn int
+		nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
+		d.nbuf += nn
 
 		// Send complete lines to Decode.
-		nl := bytes.LastIndex(d.buf[0:d.nbuf], newline);
+		nl := bytes.LastIndex(d.buf[0:d.nbuf], newline)
 		if nl < 0 {
 			continue
 		}
-		nn, d.err = Decode(&d.outbuf, d.buf[0:nl+1]);
+		nn, d.err = Decode(&d.outbuf, d.buf[0:nl+1])
 		if e, ok := d.err.(CorruptInputError); ok {
 			d.err = CorruptInputError(int64(e) + d.off)
 		}
-		d.out = d.outbuf[0:nn];
-		d.nbuf = copy(&d.buf, d.buf[nl+1:d.nbuf]);
-		d.off += int64(nl + 1);
+		d.out = d.outbuf[0:nn]
+		d.nbuf = copy(&d.buf, d.buf[nl+1:d.nbuf])
+		d.off += int64(nl + 1)
 	}
-	panic("unreacahable");
+	panic("unreacahable")
 }
diff --git a/src/pkg/encoding/git85/git_test.go b/src/pkg/encoding/git85/git_test.go
index 564b4915be..4a42282fe4 100644
--- a/src/pkg/encoding/git85/git_test.go
+++ b/src/pkg/encoding/git85/git_test.go
@@ -5,36 +5,36 @@
 package git85
 
 import (
-	"bytes";
-	"io/ioutil";
-	"os";
-	"reflect";
-	"strings";
-	"testing";
+	"bytes"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 type testpair struct {
-	decoded, encoded string;
+	decoded, encoded string
 }
 
 func testEqual(t *testing.T, msg string, args ...) bool {
-	v := reflect.NewValue(args).(*reflect.StructValue);
-	v1 := v.Field(v.NumField() - 2);
-	v2 := v.Field(v.NumField() - 1);
+	v := reflect.NewValue(args).(*reflect.StructValue)
+	v1 := v.Field(v.NumField() - 2)
+	v2 := v.Field(v.NumField() - 1)
 	if v1.Interface() != v2.Interface() {
-		t.Errorf(msg, args);
-		return false;
+		t.Errorf(msg, args)
+		return false
 	}
-	return true;
+	return true
 }
 
 func TestGitTable(t *testing.T) {
-	var saw [256]bool;
+	var saw [256]bool
 	for i, c := range encode {
 		if decode[c] != uint8(i+1) {
 			t.Errorf("decode['%c'] = %d, want %d", c, decode[c], i+1)
 		}
-		saw[c] = true;
+		saw[c] = true
 	}
 	for i, b := range saw {
 		if !b && decode[i] != 0 {
@@ -64,65 +64,65 @@ var gitBigtest = gitPairs[len(gitPairs)-1]
 
 func TestEncode(t *testing.T) {
 	for _, p := range gitPairs {
-		buf := make([]byte, EncodedLen(len(p.decoded)));
-		n := Encode(buf, strings.Bytes(p.decoded));
+		buf := make([]byte, EncodedLen(len(p.decoded)))
+		n := Encode(buf, strings.Bytes(p.decoded))
 		if n != len(buf) {
 			t.Errorf("EncodedLen does not agree with Encode")
 		}
-		buf = buf[0:n];
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded);
+		buf = buf[0:n]
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, string(buf), p.encoded)
 	}
 }
 
 func TestEncoder(t *testing.T) {
 	for _, p := range gitPairs {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(bb);
-		encoder.Write(strings.Bytes(p.decoded));
-		encoder.Close();
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded);
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(bb)
+		encoder.Write(strings.Bytes(p.decoded))
+		encoder.Close()
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
 	}
 }
 
 func TestEncoderBuffering(t *testing.T) {
-	input := strings.Bytes(gitBigtest.decoded);
+	input := strings.Bytes(gitBigtest.decoded)
 	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(bb);
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(bb)
 		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs;
+			end := pos + bs
 			if end > len(input) {
 				end = len(input)
 			}
-			n, err := encoder.Write(input[pos:end]);
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil));
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos);
+			n, err := encoder.Write(input[pos:end])
+			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
+			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
 		}
-		err := encoder.Close();
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil));
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, gitBigtest.decoded, bb.String(), gitBigtest.encoded);
+		err := encoder.Close()
+		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
+		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, gitBigtest.decoded, bb.String(), gitBigtest.encoded)
 	}
 }
 
 func TestDecode(t *testing.T) {
 	for _, p := range gitPairs {
-		dbuf := make([]byte, 4*len(p.encoded));
-		ndst, err := Decode(dbuf, strings.Bytes(p.encoded));
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil));
-		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded));
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded);
+		dbuf := make([]byte, 4*len(p.encoded))
+		ndst, err := Decode(dbuf, strings.Bytes(p.encoded))
+		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
+		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
+		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
 	}
 }
 
 func TestDecoder(t *testing.T) {
 	for _, p := range gitPairs {
-		decoder := NewDecoder(bytes.NewBufferString(p.encoded));
-		dbuf, err := ioutil.ReadAll(decoder);
+		decoder := NewDecoder(bytes.NewBufferString(p.encoded))
+		dbuf, err := ioutil.ReadAll(decoder)
 		if err != nil {
 			t.Fatal("Read failed", err)
 		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded));
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded);
+		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
+		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
 		if err != nil {
 			testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
 		}
@@ -131,31 +131,31 @@ func TestDecoder(t *testing.T) {
 
 func TestDecoderBuffering(t *testing.T) {
 	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(bytes.NewBufferString(gitBigtest.encoded));
-		buf := make([]byte, len(gitBigtest.decoded)+12);
-		var total int;
+		decoder := NewDecoder(bytes.NewBufferString(gitBigtest.encoded))
+		buf := make([]byte, len(gitBigtest.decoded)+12)
+		var total int
 		for total = 0; total < len(gitBigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs]);
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", gitBigtest.encoded, total, n, err, os.Error(nil));
-			total += n;
+			n, err := decoder.Read(buf[total : total+bs])
+			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", gitBigtest.encoded, total, n, err, os.Error(nil))
+			total += n
 		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, gitBigtest.encoded, string(buf[0:total]), gitBigtest.decoded);
+		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, gitBigtest.encoded, string(buf[0:total]), gitBigtest.decoded)
 	}
 }
 
 func TestDecodeCorrupt(t *testing.T) {
 	type corrupt struct {
-		e	string;
-		p	int;
+		e string
+		p int
 	}
 	examples := []corrupt{
 		corrupt{"v", 0},
 		corrupt{"!z!!!!!!!!!", 0},
-	};
+	}
 
 	for _, e := range examples {
-		dbuf := make([]byte, 2*len(e.e));
-		_, err := Decode(dbuf, strings.Bytes(e.e));
+		dbuf := make([]byte, 2*len(e.e))
+		_, err := Decode(dbuf, strings.Bytes(e.e))
 		switch err := err.(type) {
 		case CorruptInputError:
 			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
@@ -166,34 +166,34 @@ func TestDecodeCorrupt(t *testing.T) {
 }
 
 func TestGitBig(t *testing.T) {
-	n := 3*1000 + 1;
-	raw := make([]byte, n);
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	n := 3*1000 + 1
+	raw := make([]byte, n)
+	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	for i := 0; i < n; i++ {
 		raw[i] = alpha[i%len(alpha)]
 	}
-	encoded := new(bytes.Buffer);
-	w := NewEncoder(encoded);
-	nn, err := w.Write(raw);
+	encoded := new(bytes.Buffer)
+	w := NewEncoder(encoded)
+	nn, err := w.Write(raw)
 	if nn != n || err != nil {
 		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
 	}
-	err = w.Close();
+	err = w.Close()
 	if err != nil {
 		t.Fatalf("Encoder.Close() = %v want nil", err)
 	}
-	decoded, err := ioutil.ReadAll(NewDecoder(encoded));
+	decoded, err := ioutil.ReadAll(NewDecoder(encoded))
 	if err != nil {
 		t.Fatalf("ioutil.ReadAll(NewDecoder(...)): %v", err)
 	}
 
 	if !bytes.Equal(raw, decoded) {
-		var i int;
+		var i int
 		for i = 0; i < len(decoded) && i < len(raw); i++ {
 			if decoded[i] != raw[i] {
 				break
 			}
 		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i);
+		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
 	}
 }
diff --git a/src/pkg/encoding/hex/hex.go b/src/pkg/encoding/hex/hex.go
index 17c4ae842e..8a9271c237 100644
--- a/src/pkg/encoding/hex/hex.go
+++ b/src/pkg/encoding/hex/hex.go
@@ -6,15 +6,15 @@
 package hex
 
 import (
-	"os";
-	"strconv";
-	"strings";
+	"os"
+	"strconv"
+	"strings"
 )
 
 const hextable = "0123456789abcdef"
 
 // EncodedLen returns the length of an encoding of n source bytes.
-func EncodedLen(n int) int	{ return n * 2 }
+func EncodedLen(n int) int { return n * 2 }
 
 // Encode encodes src into EncodedLen(len(src))
 // bytes of dst.  As a convenience, it returns the number
@@ -22,17 +22,17 @@ func EncodedLen(n int) int	{ return n * 2 }
 // Encode implements hexadecimal encoding.
 func Encode(dst, src []byte) int {
 	for i, v := range src {
-		dst[i*2] = hextable[v>>4];
-		dst[i*2+1] = hextable[v&0x0f];
+		dst[i*2] = hextable[v>>4]
+		dst[i*2+1] = hextable[v&0x0f]
 	}
 
-	return len(src) * 2;
+	return len(src) * 2
 }
 
 // OddLengthInputError results from decoding an odd length slice.
 type OddLengthInputError struct{}
 
-func (OddLengthInputError) String() string	{ return "odd length hex string" }
+func (OddLengthInputError) String() string { return "odd length hex string" }
 
 // InvalidHexCharError results from finding an invalid character in a hex string.
 type InvalidHexCharError byte
@@ -42,7 +42,7 @@ func (e InvalidHexCharError) String() string {
 }
 
 
-func DecodedLen(x int) int	{ return x / 2 }
+func DecodedLen(x int) int { return x / 2 }
 
 // Decode decodes src into DecodedLen(len(src)) bytes, returning the actual
 // number of bytes written to dst.
@@ -55,18 +55,18 @@ func Decode(dst, src []byte) (int, os.Error) {
 	}
 
 	for i := 0; i < len(src)/2; i++ {
-		a, ok := fromHexChar(src[i*2]);
+		a, ok := fromHexChar(src[i*2])
 		if !ok {
 			return 0, InvalidHexCharError(src[i*2])
 		}
-		b, ok := fromHexChar(src[i*2+1]);
+		b, ok := fromHexChar(src[i*2+1])
 		if !ok {
 			return 0, InvalidHexCharError(src[i*2+1])
 		}
-		dst[i] = (a << 4) | b;
+		dst[i] = (a << 4) | b
 	}
 
-	return len(src) / 2, nil;
+	return len(src) / 2, nil
 }
 
 // fromHexChar converts a hex character into its value and a success flag.
@@ -80,23 +80,23 @@ func fromHexChar(c byte) (byte, bool) {
 		return c - 'A' + 10, true
 	}
 
-	return 0, false;
+	return 0, false
 }
 
 // EncodeToString returns the hexadecimal encoding of src.
 func EncodeToString(src []byte) string {
-	dst := make([]byte, EncodedLen(len(src)));
-	Encode(dst, src);
-	return string(dst);
+	dst := make([]byte, EncodedLen(len(src)))
+	Encode(dst, src)
+	return string(dst)
 }
 
 // DecodeString returns the bytes represented by the hexadecimal string s.
 func DecodeString(s string) ([]byte, os.Error) {
-	src := strings.Bytes(s);
-	dst := make([]byte, DecodedLen(len(src)));
-	_, err := Decode(dst, src);
+	src := strings.Bytes(s)
+	dst := make([]byte, DecodedLen(len(src)))
+	_, err := Decode(dst, src)
 	if err != nil {
 		return nil, err
 	}
-	return dst, nil;
+	return dst, nil
 }
diff --git a/src/pkg/encoding/hex/hex_test.go b/src/pkg/encoding/hex/hex_test.go
index e409dbd1e5..d741e595a1 100644
--- a/src/pkg/encoding/hex/hex_test.go
+++ b/src/pkg/encoding/hex/hex_test.go
@@ -5,12 +5,12 @@
 package hex
 
 import (
-	"bytes";
-	"testing";
+	"bytes"
+	"testing"
 )
 
 type encodeTest struct {
-	in, out []byte;
+	in, out []byte
 }
 
 var encodeTests = []encodeTest{
@@ -38,8 +38,8 @@ var encodeTests = []encodeTest{
 
 func TestEncode(t *testing.T) {
 	for i, test := range encodeTests {
-		dst := make([]byte, EncodedLen(len(test.in)));
-		n := Encode(dst, test.in);
+		dst := make([]byte, EncodedLen(len(test.in)))
+		n := Encode(dst, test.in)
 		if n != len(dst) {
 			t.Errorf("#%d: bad return value: got: %d want: %d", i, n, len(dst))
 		}
@@ -50,8 +50,8 @@ func TestEncode(t *testing.T) {
 }
 
 type decodeTest struct {
-	in, out	[]byte;
-	ok	bool;
+	in, out []byte
+	ok      bool
 }
 
 var decodeTests = []decodeTest{
@@ -84,8 +84,8 @@ var decodeTests = []decodeTest{
 
 func TestDecode(t *testing.T) {
 	for i, test := range decodeTests {
-		dst := make([]byte, DecodedLen(len(test.in)));
-		n, err := Decode(dst, test.in);
+		dst := make([]byte, DecodedLen(len(test.in)))
+		n, err := Decode(dst, test.in)
 		if err == nil && n != len(dst) {
 			t.Errorf("#%d: bad return value: got:%d want:%d", i, n, len(dst))
 		}
@@ -99,8 +99,8 @@ func TestDecode(t *testing.T) {
 }
 
 type encodeStringTest struct {
-	in	[]byte;
-	out	string;
+	in  []byte
+	out string
 }
 
 var encodeStringTests = []encodeStringTest{
@@ -112,7 +112,7 @@ var encodeStringTests = []encodeStringTest{
 
 func TestEncodeToString(t *testing.T) {
 	for i, test := range encodeStringTests {
-		s := EncodeToString(test.in);
+		s := EncodeToString(test.in)
 		if s != test.out {
 			t.Errorf("#%d got:%s want:%s", i, s, test.out)
 		}
@@ -120,9 +120,9 @@ func TestEncodeToString(t *testing.T) {
 }
 
 type decodeStringTest struct {
-	in	string;
-	out	[]byte;
-	ok	bool;
+	in  string
+	out []byte
+	ok  bool
 }
 
 var decodeStringTests = []decodeStringTest{
@@ -136,7 +136,7 @@ var decodeStringTests = []decodeStringTest{
 
 func TestDecodeString(t *testing.T) {
 	for i, test := range decodeStringTests {
-		dst, err := DecodeString(test.in);
+		dst, err := DecodeString(test.in)
 		if test.ok != (err == nil) {
 			t.Errorf("#%d: unexpected err value: %s", i, err)
 		}
diff --git a/src/pkg/encoding/pem/pem.go b/src/pkg/encoding/pem/pem.go
index 7828d87c1c..168a47168d 100644
--- a/src/pkg/encoding/pem/pem.go
+++ b/src/pkg/encoding/pem/pem.go
@@ -8,9 +8,9 @@
 package pem
 
 import (
-	"bytes";
-	"encoding/base64";
-	"strings";
+	"bytes"
+	"encoding/base64"
+	"strings"
 )
 
 // A Block represents a PEM encoded structure.
@@ -22,9 +22,9 @@ import (
 //    -----END Type-----
 // where Headers is a possibly empty sequence of Key: Value lines.
 type Block struct {
-	Type	string;			// The type, taken from the preamble (i.e. "RSA PRIVATE KEY").
-	Headers	map[string]string;	// Optional headers.
-	Bytes	[]byte;			// The decoded bytes of the contents. Typically a DER encoded ASN.1 structure.
+	Type    string            // The type, taken from the preamble (i.e. "RSA PRIVATE KEY").
+	Headers map[string]string // Optional headers.
+	Bytes   []byte            // The decoded bytes of the contents. Typically a DER encoded ASN.1 structure.
 }
 
 // getLine results the first \r\n or \n delineated line from the given byte
@@ -32,35 +32,35 @@ type Block struct {
 // array (also not including the new line bytes) is also returned and this will
 // always be smaller than the original argument.
 func getLine(data []byte) (line, rest []byte) {
-	i := bytes.Index(data, []byte{'\n'});
-	var j int;
+	i := bytes.Index(data, []byte{'\n'})
+	var j int
 	if i < 0 {
-		i = len(data);
-		j = i;
+		i = len(data)
+		j = i
 	} else {
-		j = i + 1;
+		j = i + 1
 		if i > 0 && data[i-1] == '\r' {
 			i--
 		}
 	}
-	return data[0:i], data[j:];
+	return data[0:i], data[j:]
 }
 
 // removeWhitespace returns a copy of its input with all spaces, tab and
 // newline characters removed.
 func removeWhitespace(data []byte) []byte {
-	result := make([]byte, len(data));
-	n := 0;
+	result := make([]byte, len(data))
+	n := 0
 
 	for _, b := range data {
 		if b == ' ' || b == '\t' || b == '\r' || b == '\n' {
 			continue
 		}
-		result[n] = b;
-		n++;
+		result[n] = b
+		n++
 	}
 
-	return result[0:n];
+	return result[0:n]
 }
 
 var pemStart = strings.Bytes("\n-----BEGIN ")
@@ -74,7 +74,7 @@ var pemEndOfLine = strings.Bytes("-----")
 func Decode(data []byte) (p *Block, rest []byte) {
 	// pemStart begins with a newline. However, at the very beginning of
 	// the byte array, we'll accept the start string without it.
-	rest = data;
+	rest = data
 	if bytes.HasPrefix(data, pemStart[1:]) {
 		rest = rest[len(pemStart)-1 : len(data)]
 	} else if i := bytes.Index(data, pemStart); i >= 0 {
@@ -83,16 +83,16 @@ func Decode(data []byte) (p *Block, rest []byte) {
 		return nil, data
 	}
 
-	typeLine, rest := getLine(rest);
+	typeLine, rest := getLine(rest)
 	if !bytes.HasSuffix(typeLine, pemEndOfLine) {
 		goto Error
 	}
-	typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)];
+	typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)]
 
 	p = &Block{
 		Headers: make(map[string]string),
 		Type: string(typeLine),
-	};
+	}
 
 	for {
 		// This loop terminates because getLine's second result is
@@ -100,37 +100,37 @@ func Decode(data []byte) (p *Block, rest []byte) {
 		if len(rest) == 0 {
 			return nil, data
 		}
-		line, next := getLine(rest);
+		line, next := getLine(rest)
 
-		i := bytes.Index(line, []byte{':'});
+		i := bytes.Index(line, []byte{':'})
 		if i == -1 {
 			break
 		}
 
 		// TODO(agl): need to cope with values that spread across lines.
-		key, val := line[0:i], line[i+1:];
-		key = bytes.TrimSpace(key);
-		val = bytes.TrimSpace(val);
-		p.Headers[string(key)] = string(val);
-		rest = next;
+		key, val := line[0:i], line[i+1:]
+		key = bytes.TrimSpace(key)
+		val = bytes.TrimSpace(val)
+		p.Headers[string(key)] = string(val)
+		rest = next
 	}
 
-	i := bytes.Index(rest, pemEnd);
+	i := bytes.Index(rest, pemEnd)
 	if i < 0 {
 		goto Error
 	}
-	base64Data := removeWhitespace(rest[0:i]);
+	base64Data := removeWhitespace(rest[0:i])
 
-	p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data)));
-	n, err := base64.StdEncoding.Decode(p.Bytes, base64Data);
+	p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data)))
+	n, err := base64.StdEncoding.Decode(p.Bytes, base64Data)
 	if err != nil {
 		goto Error
 	}
-	p.Bytes = p.Bytes[0:n];
+	p.Bytes = p.Bytes[0:n]
 
-	_, rest = getLine(rest[i+len(pemEnd):]);
+	_, rest = getLine(rest[i+len(pemEnd):])
 
-	return;
+	return
 
 Error:
 	// If we get here then we have rejected a likely looking, but
@@ -153,9 +153,9 @@ Error:
 	//
 	// we've failed to parse using the first BEGIN line
 	// and now will try again, using the second BEGIN line.
-	p, rest = Decode(rest);
+	p, rest = Decode(rest)
 	if p == nil {
 		rest = data
 	}
-	return;
+	return
 }
diff --git a/src/pkg/encoding/pem/pem_test.go b/src/pkg/encoding/pem/pem_test.go
index 262dadd373..47b96e97f4 100644
--- a/src/pkg/encoding/pem/pem_test.go
+++ b/src/pkg/encoding/pem/pem_test.go
@@ -5,13 +5,13 @@
 package pem
 
 import (
-	"testing";
-	"strings";
-	"reflect";
+	"testing"
+	"strings"
+	"reflect"
 )
 
 type GetLineTest struct {
-	in, out1, out2 string;
+	in, out1, out2 string
 }
 
 var getLineTests = []GetLineTest{
@@ -27,7 +27,7 @@ var getLineTests = []GetLineTest{
 
 func TestGetLine(t *testing.T) {
 	for i, test := range getLineTests {
-		x, y := getLine(strings.Bytes(test.in));
+		x, y := getLine(strings.Bytes(test.in))
 		if string(x) != test.out1 || string(y) != test.out2 {
 			t.Errorf("#%d got:%+v,%+v want:%s,%s", i, x, y, test.out1, test.out2)
 		}
@@ -35,15 +35,15 @@ func TestGetLine(t *testing.T) {
 }
 
 func TestDecode(t *testing.T) {
-	result, remainder := Decode(strings.Bytes(pemData));
+	result, remainder := Decode(strings.Bytes(pemData))
 	if !reflect.DeepEqual(result, certificate) {
 		t.Errorf("#0 got:%#v want:%#v", result, certificate)
 	}
-	result, remainder = Decode(remainder);
+	result, remainder = Decode(remainder)
 	if !reflect.DeepEqual(result, privateKey) {
 		t.Errorf("#1 got:%#v want:%#v", result, privateKey)
 	}
-	result, _ = Decode(strings.Bytes(pemPrivateKey));
+	result, _ = Decode(strings.Bytes(pemPrivateKey))
 	if !reflect.DeepEqual(result, privateKey2) {
 		t.Errorf("#2 got:%#v want:%#v", result, privateKey2)
 	}