1) Change default gofmt default settings for

                  parsing and printing to new syntax.

                  Use -oldparser to parse the old syntax,
                  use -oldprinter to print the old syntax.

               2) Change default gofmt formatting settings
                  to use tabs for indentation only and to use
                  spaces for alignment. This will make the code
                  alignment insensitive to an editor's tabwidth.

                  Use -spaces=false to use tabs for alignment.

               3) Manually changed src/exp/parser/parser_test.go
                  so that it doesn't try to parse the parser's
                  source files using the old syntax (they have
                  new syntax now).

               4) gofmt -w src misc test/bench

	       1st set of files.

R=rsc
CC=agl, golang-dev, iant, ken2, r
http://codereview.appspot.com/180047

5 files changed, 258 insertions, 258 deletions

diff --git a/src/pkg/archive/tar/common.go b/src/pkg/archive/tar/common.go
index 792a3050b..4d399e5fe 100644
--- a/src/pkg/archive/tar/common.go
+++ b/src/pkg/archive/tar/common.go
@@ -12,39 +12,39 @@
 package tar
 
 const (
-	blockSize	= 512;
+	blockSize = 512
 
 	// Types
-	TypeReg			= '0';
-	TypeRegA		= '\x00';
-	TypeLink		= '1';
-	TypeSymlink		= '2';
-	TypeChar		= '3';
-	TypeBlock		= '4';
-	TypeDir			= '5';
-	TypeFifo		= '6';
-	TypeCont		= '7';
-	TypeXHeader		= 'x';
-	TypeXGlobalHeader	= 'g';
+	TypeReg           = '0'
+	TypeRegA          = '\x00'
+	TypeLink          = '1'
+	TypeSymlink       = '2'
+	TypeChar          = '3'
+	TypeBlock         = '4'
+	TypeDir           = '5'
+	TypeFifo          = '6'
+	TypeCont          = '7'
+	TypeXHeader       = 'x'
+	TypeXGlobalHeader = 'g'
 )
 
 // A Header represents a single header in a tar archive.
 // Some fields may not be populated.
 type Header struct {
-	Name		string;
-	Mode		int64;
-	Uid		int64;
-	Gid		int64;
-	Size		int64;
-	Mtime		int64;
-	Typeflag	byte;
-	Linkname	string;
-	Uname		string;
-	Gname		string;
-	Devmajor	int64;
-	Devminor	int64;
-	Atime		int64;
-	Ctime		int64;
+	Name     string
+	Mode     int64
+	Uid      int64
+	Gid      int64
+	Size     int64
+	Mtime    int64
+	Typeflag byte
+	Linkname string
+	Uname    string
+	Gname    string
+	Devmajor int64
+	Devminor int64
+	Atime    int64
+	Ctime    int64
 }
 
 var zeroBlock = make([]byte, blockSize)
@@ -55,21 +55,21 @@ func checksum(header []byte) (unsigned int64, signed int64) {
 	for i := 0; i < len(header); i++ {
 		if i == 148 {
 			// The chksum field (header[148:156]) is special: it should be treated as space bytes.
-			unsigned += ' ' * 8;
-			signed += ' ' * 8;
-			i += 7;
-			continue;
+			unsigned += ' ' * 8
+			signed += ' ' * 8
+			i += 7
+			continue
 		}
-		unsigned += int64(header[i]);
-		signed += int64(int8(header[i]));
+		unsigned += int64(header[i])
+		signed += int64(int8(header[i]))
 	}
-	return;
+	return
 }
 
 type slicer []byte
 
 func (sp *slicer) next(n int) (b []byte) {
-	s := *sp;
-	b, *sp = s[0:n], s[n:];
-	return;
+	s := *sp
+	b, *sp = s[0:n], s[n:]
+	return
 }
diff --git a/src/pkg/archive/tar/reader.go b/src/pkg/archive/tar/reader.go
index 50cda624b..9d598361a 100644
--- a/src/pkg/archive/tar/reader.go
+++ b/src/pkg/archive/tar/reader.go
@@ -8,14 +8,14 @@ package tar
 //   - pax extensions
 
 import (
-	"bytes";
-	"io";
-	"os";
-	"strconv";
+	"bytes"
+	"io"
+	"os"
+	"strconv"
 )
 
 var (
-	HeaderError os.Error = os.ErrorString("invalid tar header");
+	HeaderError os.Error = os.ErrorString("invalid tar header")
 )
 
 // A Reader provides sequential access to the contents of a tar archive.
@@ -37,35 +37,35 @@ var (
 //		io.Copy(data, tr);
 //	}
 type Reader struct {
-	r	io.Reader;
-	err	os.Error;
-	nb	int64;	// number of unread bytes for current file entry
-	pad	int64;	// amount of padding (ignored) after current file entry
+	r   io.Reader
+	err os.Error
+	nb  int64 // number of unread bytes for current file entry
+	pad int64 // amount of padding (ignored) after current file entry
 }
 
 // NewReader creates a new Reader reading from r.
-func NewReader(r io.Reader) *Reader	{ return &Reader{r: r} }
+func NewReader(r io.Reader) *Reader { return &Reader{r: r} }
 
 // Next advances to the next entry in the tar archive.
 func (tr *Reader) Next() (*Header, os.Error) {
-	var hdr *Header;
+	var hdr *Header
 	if tr.err == nil {
 		tr.skipUnread()
 	}
 	if tr.err == nil {
 		hdr = tr.readHeader()
 	}
-	return hdr, tr.err;
+	return hdr, tr.err
 }
 
 // Parse bytes as a NUL-terminated C-style string.
 // If a NUL byte is not found then the whole slice is returned as a string.
 func cString(b []byte) string {
-	n := 0;
+	n := 0
 	for n < len(b) && b[n] != 0 {
 		n++
 	}
-	return string(b[0:n]);
+	return string(b[0:n])
 }
 
 func (tr *Reader) octal(b []byte) int64 {
@@ -77,11 +77,11 @@ func (tr *Reader) octal(b []byte) int64 {
 	for len(b) > 0 && (b[len(b)-1] == ' ' || b[len(b)-1] == '\x00') {
 		b = b[0 : len(b)-1]
 	}
-	x, err := strconv.Btoui64(cString(b), 8);
+	x, err := strconv.Btoui64(cString(b), 8)
 	if err != nil {
 		tr.err = err
 	}
-	return int64(x);
+	return int64(x)
 }
 
 type ignoreWriter struct{}
@@ -92,14 +92,14 @@ func (ignoreWriter) Write(b []byte) (n int, err os.Error) {
 
 // Skip any unread bytes in the existing file entry, as well as any alignment padding.
 func (tr *Reader) skipUnread() {
-	nr := tr.nb + tr.pad;	// number of bytes to skip
-	tr.nb, tr.pad = 0, 0;
+	nr := tr.nb + tr.pad // number of bytes to skip
+	tr.nb, tr.pad = 0, 0
 	if sr, ok := tr.r.(io.Seeker); ok {
 		if _, err := sr.Seek(nr, 1); err == nil {
 			return
 		}
 	}
-	_, tr.err = io.Copyn(ignoreWriter{}, tr.r, nr);
+	_, tr.err = io.Copyn(ignoreWriter{}, tr.r, nr)
 }
 
 func (tr *Reader) verifyChecksum(header []byte) bool {
@@ -107,13 +107,13 @@ func (tr *Reader) verifyChecksum(header []byte) bool {
 		return false
 	}
 
-	given := tr.octal(header[148:156]);
-	unsigned, signed := checksum(header);
-	return given == unsigned || given == signed;
+	given := tr.octal(header[148:156])
+	unsigned, signed := checksum(header)
+	return given == unsigned || given == signed
 }
 
 func (tr *Reader) readHeader() *Header {
-	header := make([]byte, blockSize);
+	header := make([]byte, blockSize)
 	if _, tr.err = io.ReadFull(tr.r, header); tr.err != nil {
 		return nil
 	}
@@ -126,64 +126,64 @@ func (tr *Reader) readHeader() *Header {
 		if bytes.Equal(header, zeroBlock[0:blockSize]) {
 			tr.err = os.EOF
 		} else {
-			tr.err = HeaderError	// zero block and then non-zero block
+			tr.err = HeaderError // zero block and then non-zero block
 		}
-		return nil;
+		return nil
 	}
 
 	if !tr.verifyChecksum(header) {
-		tr.err = HeaderError;
-		return nil;
+		tr.err = HeaderError
+		return nil
 	}
 
 	// Unpack
-	hdr := new(Header);
-	s := slicer(header);
-
-	hdr.Name = cString(s.next(100));
-	hdr.Mode = tr.octal(s.next(8));
-	hdr.Uid = tr.octal(s.next(8));
-	hdr.Gid = tr.octal(s.next(8));
-	hdr.Size = tr.octal(s.next(12));
-	hdr.Mtime = tr.octal(s.next(12));
-	s.next(8);	// chksum
-	hdr.Typeflag = s.next(1)[0];
-	hdr.Linkname = cString(s.next(100));
+	hdr := new(Header)
+	s := slicer(header)
+
+	hdr.Name = cString(s.next(100))
+	hdr.Mode = tr.octal(s.next(8))
+	hdr.Uid = tr.octal(s.next(8))
+	hdr.Gid = tr.octal(s.next(8))
+	hdr.Size = tr.octal(s.next(12))
+	hdr.Mtime = tr.octal(s.next(12))
+	s.next(8) // chksum
+	hdr.Typeflag = s.next(1)[0]
+	hdr.Linkname = cString(s.next(100))
 
 	// The remainder of the header depends on the value of magic.
 	// The original (v7) version of tar had no explicit magic field,
 	// so its magic bytes, like the rest of the block, are NULs.
-	magic := string(s.next(8));	// contains version field as well.
-	var format string;
+	magic := string(s.next(8)) // contains version field as well.
+	var format string
 	switch magic {
-	case "ustar\x0000":	// POSIX tar (1003.1-1988)
+	case "ustar\x0000": // POSIX tar (1003.1-1988)
 		if string(header[508:512]) == "tar\x00" {
 			format = "star"
 		} else {
 			format = "posix"
 		}
-	case "ustar  \x00":	// old GNU tar
+	case "ustar  \x00": // old GNU tar
 		format = "gnu"
 	}
 
 	switch format {
 	case "posix", "gnu", "star":
-		hdr.Uname = cString(s.next(32));
-		hdr.Gname = cString(s.next(32));
-		devmajor := s.next(8);
-		devminor := s.next(8);
+		hdr.Uname = cString(s.next(32))
+		hdr.Gname = cString(s.next(32))
+		devmajor := s.next(8)
+		devminor := s.next(8)
 		if hdr.Typeflag == TypeChar || hdr.Typeflag == TypeBlock {
-			hdr.Devmajor = tr.octal(devmajor);
-			hdr.Devminor = tr.octal(devminor);
+			hdr.Devmajor = tr.octal(devmajor)
+			hdr.Devminor = tr.octal(devminor)
 		}
-		var prefix string;
+		var prefix string
 		switch format {
 		case "posix", "gnu":
 			prefix = cString(s.next(155))
 		case "star":
-			prefix = cString(s.next(131));
-			hdr.Atime = tr.octal(s.next(12));
-			hdr.Ctime = tr.octal(s.next(12));
+			prefix = cString(s.next(131))
+			hdr.Atime = tr.octal(s.next(12))
+			hdr.Ctime = tr.octal(s.next(12))
 		}
 		if len(prefix) > 0 {
 			hdr.Name = prefix + "/" + hdr.Name
@@ -191,16 +191,16 @@ func (tr *Reader) readHeader() *Header {
 	}
 
 	if tr.err != nil {
-		tr.err = HeaderError;
-		return nil;
+		tr.err = HeaderError
+		return nil
 	}
 
 	// Maximum value of hdr.Size is 64 GB (12 octal digits),
 	// so there's no risk of int64 overflowing.
-	tr.nb = int64(hdr.Size);
-	tr.pad = -tr.nb & (blockSize - 1);	// blockSize is a power of two
+	tr.nb = int64(hdr.Size)
+	tr.pad = -tr.nb & (blockSize - 1) // blockSize is a power of two
 
-	return hdr;
+	return hdr
 }
 
 // Read reads from the current entry in the tar archive.
@@ -215,12 +215,12 @@ func (tr *Reader) Read(b []byte) (n int, err os.Error) {
 	if int64(len(b)) > tr.nb {
 		b = b[0:tr.nb]
 	}
-	n, err = tr.r.Read(b);
-	tr.nb -= int64(n);
+	n, err = tr.r.Read(b)
+	tr.nb -= int64(n)
 
 	if err == os.EOF && tr.nb > 0 {
 		err = io.ErrUnexpectedEOF
 	}
-	tr.err = err;
-	return;
+	tr.err = err
+	return
 }
diff --git a/src/pkg/archive/tar/reader_test.go b/src/pkg/archive/tar/reader_test.go
index f5a77dd38..719e3d87e 100644
--- a/src/pkg/archive/tar/reader_test.go
+++ b/src/pkg/archive/tar/reader_test.go
@@ -5,20 +5,20 @@
 package tar
 
 import (
-	"bytes";
-	"crypto/md5";
-	"fmt";
-	"io";
-	"os";
-	"reflect";
-	"strings";
-	"testing";
+	"bytes"
+	"crypto/md5"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 type untarTest struct {
-	file	string;
-	headers	[]*Header;
-	cksums	[]string;
+	file    string
+	headers []*Header
+	cksums  []string
 }
 
 var gnuTarTest = &untarTest{
@@ -114,50 +114,50 @@ var untarTests = []*untarTest{
 func TestReader(t *testing.T) {
 testLoop:
 	for i, test := range untarTests {
-		f, err := os.Open(test.file, os.O_RDONLY, 0444);
+		f, err := os.Open(test.file, os.O_RDONLY, 0444)
 		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err);
-			continue;
+			t.Errorf("test %d: Unexpected error: %v", i, err)
+			continue
 		}
-		tr := NewReader(f);
+		tr := NewReader(f)
 		for j, header := range test.headers {
-			hdr, err := tr.Next();
+			hdr, err := tr.Next()
 			if err != nil || hdr == nil {
-				t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err);
-				f.Close();
-				continue testLoop;
+				t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err)
+				f.Close()
+				continue testLoop
 			}
 			if !reflect.DeepEqual(hdr, header) {
 				t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v",
 					i, j, *hdr, *header)
 			}
 		}
-		hdr, err := tr.Next();
+		hdr, err := tr.Next()
 		if err == os.EOF {
 			break
 		}
 		if hdr != nil || err != nil {
 			t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, err)
 		}
-		f.Close();
+		f.Close()
 	}
 }
 
 func TestPartialRead(t *testing.T) {
-	f, err := os.Open("testdata/gnu.tar", os.O_RDONLY, 0444);
+	f, err := os.Open("testdata/gnu.tar", os.O_RDONLY, 0444)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	defer f.Close();
+	defer f.Close()
 
-	tr := NewReader(f);
+	tr := NewReader(f)
 
 	// Read the first four bytes; Next() should skip the last byte.
-	hdr, err := tr.Next();
+	hdr, err := tr.Next()
 	if err != nil || hdr == nil {
 		t.Fatalf("Didn't get first file: %v", err)
 	}
-	buf := make([]byte, 4);
+	buf := make([]byte, 4)
 	if _, err := io.ReadFull(tr, buf); err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -166,11 +166,11 @@ func TestPartialRead(t *testing.T) {
 	}
 
 	// Second file
-	hdr, err = tr.Next();
+	hdr, err = tr.Next()
 	if err != nil || hdr == nil {
 		t.Fatalf("Didn't get second file: %v", err)
 	}
-	buf = make([]byte, 6);
+	buf = make([]byte, 6)
 	if _, err := io.ReadFull(tr, buf); err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -181,22 +181,22 @@ func TestPartialRead(t *testing.T) {
 
 
 func TestIncrementalRead(t *testing.T) {
-	test := gnuTarTest;
-	f, err := os.Open(test.file, os.O_RDONLY, 0444);
+	test := gnuTarTest
+	f, err := os.Open(test.file, os.O_RDONLY, 0444)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	defer f.Close();
+	defer f.Close()
 
-	tr := NewReader(f);
+	tr := NewReader(f)
 
-	headers := test.headers;
-	cksums := test.cksums;
-	nread := 0;
+	headers := test.headers
+	cksums := test.cksums
+	nread := 0
 
 	// loop over all files
 	for ; ; nread++ {
-		hdr, err := tr.Next();
+		hdr, err := tr.Next()
 		if hdr == nil || err == os.EOF {
 			break
 		}
@@ -209,22 +209,22 @@ func TestIncrementalRead(t *testing.T) {
 
 		// read file contents in little chunks EOF,
 		// checksumming all the way
-		h := md5.New();
-		rdbuf := make([]uint8, 8);
+		h := md5.New()
+		rdbuf := make([]uint8, 8)
 		for {
-			nr, err := tr.Read(rdbuf);
+			nr, err := tr.Read(rdbuf)
 			if err == os.EOF {
 				break
 			}
 			if err != nil {
-				t.Errorf("Read: unexpected error %v\n", err);
-				break;
+				t.Errorf("Read: unexpected error %v\n", err)
+				break
 			}
-			h.Write(rdbuf[0:nr]);
+			h.Write(rdbuf[0:nr])
 		}
 		// verify checksum
-		have := fmt.Sprintf("%x", h.Sum());
-		want := cksums[nread];
+		have := fmt.Sprintf("%x", h.Sum())
+		want := cksums[nread]
 		if want != have {
 			t.Errorf("Bad checksum on file %s:\nhave %+v\nwant %+v", hdr.Name, have, want)
 		}
@@ -235,35 +235,35 @@ func TestIncrementalRead(t *testing.T) {
 }
 
 func TestNonSeekable(t *testing.T) {
-	test := gnuTarTest;
-	f, err := os.Open(test.file, os.O_RDONLY, 0444);
+	test := gnuTarTest
+	f, err := os.Open(test.file, os.O_RDONLY, 0444)
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
-	defer f.Close();
+	defer f.Close()
 
 	// pipe the data in
-	r, w, err := os.Pipe();
+	r, w, err := os.Pipe()
 	if err != nil {
 		t.Fatalf("Unexpected error %s", err)
 	}
 	go func() {
-		rdbuf := make([]uint8, 1<<16);
+		rdbuf := make([]uint8, 1<<16)
 		for {
-			nr, err := f.Read(rdbuf);
-			w.Write(rdbuf[0:nr]);
+			nr, err := f.Read(rdbuf)
+			w.Write(rdbuf[0:nr])
 			if err == os.EOF {
 				break
 			}
 		}
-		w.Close();
-	}();
+		w.Close()
+	}()
 
-	tr := NewReader(r);
-	nread := 0;
+	tr := NewReader(r)
+	nread := 0
 
 	for ; ; nread++ {
-		hdr, err := tr.Next();
+		hdr, err := tr.Next()
 		if hdr == nil || err == os.EOF {
 			break
 		}
diff --git a/src/pkg/archive/tar/writer.go b/src/pkg/archive/tar/writer.go
index f3ce84afa..88f9c72bd 100644
--- a/src/pkg/archive/tar/writer.go
+++ b/src/pkg/archive/tar/writer.go
@@ -8,16 +8,16 @@ package tar
 // - catch more errors (no first header, write after close, etc.)
 
 import (
-	"io";
-	"os";
-	"strconv";
-	"strings";
+	"io"
+	"os"
+	"strconv"
+	"strings"
 )
 
 var (
-	ErrWriteTooLong		= os.NewError("write too long");
-	ErrFieldTooLong		= os.NewError("header field too long");
-	ErrWriteAfterClose	= os.NewError("write after close");
+	ErrWriteTooLong    = os.NewError("write too long")
+	ErrFieldTooLong    = os.NewError("header field too long")
+	ErrWriteAfterClose = os.NewError("write after close")
 )
 
 // A Writer provides sequential writing of a tar archive in POSIX.1 format.
@@ -36,32 +36,32 @@ var (
 //	io.Copy(tw, data);
 //	tw.Close();
 type Writer struct {
-	w		io.Writer;
-	err		os.Error;
-	nb		int64;	// number of unwritten bytes for current file entry
-	pad		int64;	// amount of padding to write after current file entry
-	closed		bool;
-	usedBinary	bool;	// whether the binary numeric field extension was used
+	w          io.Writer
+	err        os.Error
+	nb         int64 // number of unwritten bytes for current file entry
+	pad        int64 // amount of padding to write after current file entry
+	closed     bool
+	usedBinary bool // whether the binary numeric field extension was used
 }
 
 // NewWriter creates a new Writer writing to w.
-func NewWriter(w io.Writer) *Writer	{ return &Writer{w: w} }
+func NewWriter(w io.Writer) *Writer { return &Writer{w: w} }
 
 // Flush finishes writing the current file (optional).
 func (tw *Writer) Flush() os.Error {
-	n := tw.nb + tw.pad;
+	n := tw.nb + tw.pad
 	for n > 0 && tw.err == nil {
-		nr := n;
+		nr := n
 		if nr > blockSize {
 			nr = blockSize
 		}
-		var nw int;
-		nw, tw.err = tw.w.Write(zeroBlock[0:nr]);
-		n -= int64(nw);
+		var nw int
+		nw, tw.err = tw.w.Write(zeroBlock[0:nr])
+		n -= int64(nw)
 	}
-	tw.nb = 0;
-	tw.pad = 0;
-	return tw.err;
+	tw.nb = 0
+	tw.pad = 0
+	return tw.err
 }
 
 // Write s into b, terminating it with a NUL if there is room.
@@ -70,7 +70,7 @@ func (tw *Writer) cString(b []byte, s string) {
 		if tw.err == nil {
 			tw.err = ErrFieldTooLong
 		}
-		return;
+		return
 	}
 	for i, ch := range strings.Bytes(s) {
 		b[i] = ch
@@ -82,29 +82,29 @@ func (tw *Writer) cString(b []byte, s string) {
 
 // Encode x as an octal ASCII string and write it into b with leading zeros.
 func (tw *Writer) octal(b []byte, x int64) {
-	s := strconv.Itob64(x, 8);
+	s := strconv.Itob64(x, 8)
 	// leading zeros, but leave room for a NUL.
 	for len(s)+1 < len(b) {
 		s = "0" + s
 	}
-	tw.cString(b, s);
+	tw.cString(b, s)
 }
 
 // Write x into b, either as octal or as binary (GNUtar/star extension).
 func (tw *Writer) numeric(b []byte, x int64) {
 	// Try octal first.
-	s := strconv.Itob64(x, 8);
+	s := strconv.Itob64(x, 8)
 	if len(s) < len(b) {
-		tw.octal(b, x);
-		return;
+		tw.octal(b, x)
+		return
 	}
 	// Too big: use binary (big-endian).
-	tw.usedBinary = true;
+	tw.usedBinary = true
 	for i := len(b) - 1; x > 0 && i >= 0; i-- {
-		b[i] = byte(x);
-		x >>= 8;
+		b[i] = byte(x)
+		x >>= 8
 	}
-	b[0] |= 0x80;	// highest bit indicates binary format
+	b[0] |= 0x80 // highest bit indicates binary format
 }
 
 // WriteHeader writes hdr and prepares to accept the file's contents.
@@ -121,28 +121,28 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 		return tw.err
 	}
 
-	tw.nb = int64(hdr.Size);
-	tw.pad = -tw.nb & (blockSize - 1);	// blockSize is a power of two
+	tw.nb = int64(hdr.Size)
+	tw.pad = -tw.nb & (blockSize - 1) // blockSize is a power of two
 
-	header := make([]byte, blockSize);
-	s := slicer(header);
+	header := make([]byte, blockSize)
+	s := slicer(header)
 
 	// TODO(dsymonds): handle names longer than 100 chars
-	copy(s.next(100), strings.Bytes(hdr.Name));
-
-	tw.octal(s.next(8), hdr.Mode);			// 100:108
-	tw.numeric(s.next(8), hdr.Uid);			// 108:116
-	tw.numeric(s.next(8), hdr.Gid);			// 116:124
-	tw.numeric(s.next(12), hdr.Size);		// 124:136
-	tw.numeric(s.next(12), hdr.Mtime);		// 136:148
-	s.next(8);					// chksum (148:156)
-	s.next(1)[0] = hdr.Typeflag;			// 156:157
-	s.next(100);					// linkname (157:257)
-	copy(s.next(8), strings.Bytes("ustar\x0000"));	// 257:265
-	tw.cString(s.next(32), hdr.Uname);		// 265:297
-	tw.cString(s.next(32), hdr.Gname);		// 297:329
-	tw.numeric(s.next(8), hdr.Devmajor);		// 329:337
-	tw.numeric(s.next(8), hdr.Devminor);		// 337:345
+	copy(s.next(100), strings.Bytes(hdr.Name))
+
+	tw.octal(s.next(8), hdr.Mode)                 // 100:108
+	tw.numeric(s.next(8), hdr.Uid)                // 108:116
+	tw.numeric(s.next(8), hdr.Gid)                // 116:124
+	tw.numeric(s.next(12), hdr.Size)              // 124:136
+	tw.numeric(s.next(12), hdr.Mtime)             // 136:148
+	s.next(8)                                     // chksum (148:156)
+	s.next(1)[0] = hdr.Typeflag                   // 156:157
+	s.next(100)                                   // linkname (157:257)
+	copy(s.next(8), strings.Bytes("ustar\x0000")) // 257:265
+	tw.cString(s.next(32), hdr.Uname)             // 265:297
+	tw.cString(s.next(32), hdr.Gname)             // 297:329
+	tw.numeric(s.next(8), hdr.Devmajor)           // 329:337
+	tw.numeric(s.next(8), hdr.Devminor)           // 337:345
 
 	// Use the GNU magic instead of POSIX magic if we used any GNU extensions.
 	if tw.usedBinary {
@@ -151,18 +151,18 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 
 	// The chksum field is terminated by a NUL and a space.
 	// This is different from the other octal fields.
-	chksum, _ := checksum(header);
-	tw.octal(header[148:155], chksum);
-	header[155] = ' ';
+	chksum, _ := checksum(header)
+	tw.octal(header[148:155], chksum)
+	header[155] = ' '
 
 	if tw.err != nil {
 		// problem with header; probably integer too big for a field.
 		return tw.err
 	}
 
-	_, tw.err = tw.w.Write(header);
+	_, tw.err = tw.w.Write(header)
 
-	return tw.err;
+	return tw.err
 }
 
 // Write writes to the current entry in the tar archive.
@@ -170,22 +170,22 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error {
 // hdr.Size bytes are written after WriteHeader.
 func (tw *Writer) Write(b []byte) (n int, err os.Error) {
 	if tw.closed {
-		err = ErrWriteTooLong;
-		return;
+		err = ErrWriteTooLong
+		return
 	}
-	overwrite := false;
+	overwrite := false
 	if int64(len(b)) > tw.nb {
-		b = b[0:tw.nb];
-		overwrite = true;
+		b = b[0:tw.nb]
+		overwrite = true
 	}
-	n, err = tw.w.Write(b);
-	tw.nb -= int64(n);
+	n, err = tw.w.Write(b)
+	tw.nb -= int64(n)
 	if err == nil && overwrite {
-		err = ErrWriteTooLong;
-		return;
+		err = ErrWriteTooLong
+		return
 	}
-	tw.err = err;
-	return;
+	tw.err = err
+	return
 }
 
 // Close closes the tar archive, flushing any unwritten
@@ -194,15 +194,15 @@ func (tw *Writer) Close() os.Error {
 	if tw.err != nil || tw.closed {
 		return tw.err
 	}
-	tw.Flush();
-	tw.closed = true;
+	tw.Flush()
+	tw.closed = true
 
 	// trailer: two zero blocks
 	for i := 0; i < 2; i++ {
-		_, tw.err = tw.w.Write(zeroBlock);
+		_, tw.err = tw.w.Write(zeroBlock)
 		if tw.err != nil {
 			break
 		}
 	}
-	return tw.err;
+	return tw.err
 }
diff --git a/src/pkg/archive/tar/writer_test.go b/src/pkg/archive/tar/writer_test.go
index 0df0144b1..f060efcbe 100644
--- a/src/pkg/archive/tar/writer_test.go
+++ b/src/pkg/archive/tar/writer_test.go
@@ -5,22 +5,22 @@
 package tar
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"io/ioutil";
-	"testing";
-	"testing/iotest";
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"testing"
+	"testing/iotest"
 )
 
 type writerTestEntry struct {
-	header		*Header;
-	contents	string;
+	header   *Header
+	contents string
 }
 
 type writerTest struct {
-	file	string;	// filename of expected output
-	entries	[]*writerTestEntry;
+	file    string // filename of expected output
+	entries []*writerTestEntry
 }
 
 var writerTests = []*writerTest{
@@ -83,8 +83,8 @@ var writerTests = []*writerTest{
 
 // Render byte array in a two-character hexadecimal string, spaced for easy visual inspection.
 func bytestr(offset int, b []byte) string {
-	const rowLen = 32;
-	s := fmt.Sprintf("%04x ", offset);
+	const rowLen = 32
+	s := fmt.Sprintf("%04x ", offset)
 	for _, ch := range b {
 		switch {
 		case '0' <= ch && ch <= '9', 'A' <= ch && ch <= 'Z', 'a' <= ch && ch <= 'z':
@@ -93,59 +93,59 @@ func bytestr(offset int, b []byte) string {
 			s += fmt.Sprintf(" %02x", ch)
 		}
 	}
-	return s;
+	return s
 }
 
 // Render a pseudo-diff between two blocks of bytes.
 func bytediff(a []byte, b []byte) string {
-	const rowLen = 32;
-	s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b));
+	const rowLen = 32
+	s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b))
 	for offset := 0; len(a)+len(b) > 0; offset += rowLen {
-		na, nb := rowLen, rowLen;
+		na, nb := rowLen, rowLen
 		if na > len(a) {
 			na = len(a)
 		}
 		if nb > len(b) {
 			nb = len(b)
 		}
-		sa := bytestr(offset, a[0:na]);
-		sb := bytestr(offset, b[0:nb]);
+		sa := bytestr(offset, a[0:na])
+		sb := bytestr(offset, b[0:nb])
 		if sa != sb {
 			s += fmt.Sprintf("-%v\n+%v\n", sa, sb)
 		}
-		a = a[na:];
-		b = b[nb:];
+		a = a[na:]
+		b = b[nb:]
 	}
-	return s;
+	return s
 }
 
 func TestWriter(t *testing.T) {
 testLoop:
 	for i, test := range writerTests {
-		expected, err := ioutil.ReadFile(test.file);
+		expected, err := ioutil.ReadFile(test.file)
 		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err);
-			continue;
+			t.Errorf("test %d: Unexpected error: %v", i, err)
+			continue
 		}
 
-		buf := new(bytes.Buffer);
-		tw := NewWriter(iotest.TruncateWriter(buf, 4<<10));	// only catch the first 4 KB
+		buf := new(bytes.Buffer)
+		tw := NewWriter(iotest.TruncateWriter(buf, 4<<10)) // only catch the first 4 KB
 		for j, entry := range test.entries {
 			if err := tw.WriteHeader(entry.header); err != nil {
-				t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err);
-				continue testLoop;
+				t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err)
+				continue testLoop
 			}
 			if _, err := io.WriteString(tw, entry.contents); err != nil {
-				t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err);
-				continue testLoop;
+				t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err)
+				continue testLoop
 			}
 		}
 		if err := tw.Close(); err != nil {
-			t.Errorf("test %d: Failed closing archive: %v", err);
-			continue testLoop;
+			t.Errorf("test %d: Failed closing archive: %v", err)
+			continue testLoop
 		}
 
-		actual := buf.Bytes();
+		actual := buf.Bytes()
 		if !bytes.Equal(expected, actual) {
 			t.Errorf("test %d: Incorrect result: (-=expected, +=actual)\n%v",
 				i, bytediff(expected, actual))