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

1 files changed, 62 insertions, 62 deletions

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
 }