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

4th set of files.

R=rsc
CC=golang-dev
http://codereview.appspot.com/180049

1 files changed, 96 insertions, 96 deletions

diff --git a/src/pkg/patch/patch.go b/src/pkg/patch/patch.go
index d04b78865..04ecd9d24 100644
--- a/src/pkg/patch/patch.go
+++ b/src/pkg/patch/patch.go
@@ -8,37 +8,37 @@
 package patch
 
 import (
-	"bytes";
-	"os";
-	"path";
-	"strings";
+	"bytes"
+	"os"
+	"path"
+	"strings"
 )
 
 // A Set represents a set of patches to be applied as a single atomic unit.
 // Patch sets are often preceded by a descriptive header.
 type Set struct {
-	Header	string;	// free-form text
-	File	[]*File;
+	Header string // free-form text
+	File   []*File
 }
 
 // A File represents a collection of changes to be made to a single file.
 type File struct {
-	Verb			Verb;
-	Src			string;	// source for Verb == Copy, Verb == Rename
-	Dst			string;
-	OldMode, NewMode	int;	// 0 indicates not used
-	Diff;				// changes to data; == NoDiff if operation does not edit file
+	Verb             Verb
+	Src              string // source for Verb == Copy, Verb == Rename
+	Dst              string
+	OldMode, NewMode int // 0 indicates not used
+	Diff                 // changes to data; == NoDiff if operation does not edit file
 }
 
 // A Verb is an action performed on a file.
 type Verb string
 
 const (
-	Add	Verb	= "add";
-	Copy	Verb	= "copy";
-	Delete	Verb	= "delete";
-	Edit	Verb	= "edit";
-	Rename	Verb	= "rename";
+	Add    Verb = "add"
+	Copy   Verb = "copy"
+	Delete Verb = "delete"
+	Edit   Verb = "edit"
+	Rename Verb = "rename"
 )
 
 // A Diff is any object that describes changes to transform
@@ -47,7 +47,7 @@ type Diff interface {
 	// Apply applies the changes listed in the diff
 	// to the string s, returning the new version of the string.
 	// Note that the string s need not be a text string.
-	Apply(old []byte) (new []byte, err os.Error);
+	Apply(old []byte) (new []byte, err os.Error)
 }
 
 // NoDiff is a no-op Diff implementation: it passes the
@@ -63,7 +63,7 @@ func (noDiffType) Apply(old []byte) ([]byte, os.Error) {
 // A SyntaxError represents a syntax error encountered while parsing a patch.
 type SyntaxError string
 
-func (e SyntaxError) String() string	{ return string(e) }
+func (e SyntaxError) String() string { return string(e) }
 
 var newline = []byte{'\n'}
 
@@ -82,37 +82,37 @@ func Parse(text []byte) (*Set, os.Error) {
 	//	diff [--git] a/file/path b/file/path.
 	//
 	// First look for Index: lines.  If none, fall back on diff lines.
-	text, files := sections(text, "Index: ");
+	text, files := sections(text, "Index: ")
 	if len(files) == 0 {
 		text, files = sections(text, "diff ")
 	}
 
-	set := &Set{string(text), make([]*File, len(files))};
+	set := &Set{string(text), make([]*File, len(files))}
 
 	// Parse file header and then
 	// parse files into patch chunks.
 	// Each chunk begins with @@.
 	for i, raw := range files {
-		p := new(File);
-		set.File[i] = p;
+		p := new(File)
+		set.File[i] = p
 
 		// First line of hdr is the Index: that
 		// begins the section.  After that is the file name.
-		s, raw, _ := getLine(raw, 1);
+		s, raw, _ := getLine(raw, 1)
 		if hasPrefix(s, "Index: ") {
-			p.Dst = string(bytes.TrimSpace(s[7:]));
-			goto HaveName;
+			p.Dst = string(bytes.TrimSpace(s[7:]))
+			goto HaveName
 		} else if hasPrefix(s, "diff ") {
-			str := string(bytes.TrimSpace(s));
-			i := strings.LastIndex(str, " b/");
+			str := string(bytes.TrimSpace(s))
+			i := strings.LastIndex(str, " b/")
 			if i >= 0 {
-				p.Dst = str[i+3:];
-				goto HaveName;
+				p.Dst = str[i+3:]
+				goto HaveName
 			}
 		}
-		return nil, SyntaxError("unexpected patch header line: " + string(s));
+		return nil, SyntaxError("unexpected patch header line: " + string(s))
 	HaveName:
-		p.Dst = path.Clean(p.Dst);
+		p.Dst = path.Clean(p.Dst)
 		if strings.HasPrefix(p.Dst, "../") || strings.HasPrefix(p.Dst, "/") {
 			return nil, SyntaxError("invalid path: " + p.Dst)
 		}
@@ -126,55 +126,55 @@ func Parse(text []byte) (*Set, os.Error) {
 		//	rename to %s
 		//	copy from %s		- file copied from other file
 		//	copy to %s
-		p.Verb = Edit;
+		p.Verb = Edit
 		for len(raw) > 0 {
-			oldraw := raw;
-			var l []byte;
-			l, raw, _ = getLine(raw, 1);
-			l = bytes.TrimSpace(l);
+			oldraw := raw
+			var l []byte
+			l, raw, _ = getLine(raw, 1)
+			l = bytes.TrimSpace(l)
 			if m, s, ok := atoi(l, "new file mode ", 8); ok && len(s) == 0 {
-				p.NewMode = m;
-				p.Verb = Add;
-				continue;
+				p.NewMode = m
+				p.Verb = Add
+				continue
 			}
 			if m, s, ok := atoi(l, "deleted file mode ", 8); ok && len(s) == 0 {
-				p.OldMode = m;
-				p.Verb = Delete;
-				p.Src = p.Dst;
-				p.Dst = "";
-				continue;
+				p.OldMode = m
+				p.Verb = Delete
+				p.Src = p.Dst
+				p.Dst = ""
+				continue
 			}
 			if m, s, ok := atoi(l, "old file mode ", 8); ok && len(s) == 0 {
 				// usually implies p.Verb = "rename" or "copy"
 				// but we'll get that from the rename or copy line.
-				p.OldMode = m;
-				continue;
+				p.OldMode = m
+				continue
 			}
 			if m, s, ok := atoi(l, "old mode ", 8); ok && len(s) == 0 {
-				p.OldMode = m;
-				continue;
+				p.OldMode = m
+				continue
 			}
 			if m, s, ok := atoi(l, "new mode ", 8); ok && len(s) == 0 {
-				p.NewMode = m;
-				continue;
+				p.NewMode = m
+				continue
 			}
 			if s, ok := skip(l, "rename from "); ok && len(s) > 0 {
-				p.Src = string(s);
-				p.Verb = Rename;
-				continue;
+				p.Src = string(s)
+				p.Verb = Rename
+				continue
 			}
 			if s, ok := skip(l, "rename to "); ok && len(s) > 0 {
-				p.Verb = Rename;
-				continue;
+				p.Verb = Rename
+				continue
 			}
 			if s, ok := skip(l, "copy from "); ok && len(s) > 0 {
-				p.Src = string(s);
-				p.Verb = Copy;
-				continue;
+				p.Src = string(s)
+				p.Verb = Copy
+				continue
 			}
 			if s, ok := skip(l, "copy to "); ok && len(s) > 0 {
-				p.Verb = Copy;
-				continue;
+				p.Verb = Copy
+				continue
 			}
 			if s, ok := skip(l, "Binary file "); ok && len(s) > 0 {
 				// Hg prints
@@ -200,22 +200,22 @@ func Parse(text []byte) (*Set, os.Error) {
 				continue
 			}
 			if hasPrefix(l, "@@ -") {
-				diff, err := ParseTextDiff(oldraw);
+				diff, err := ParseTextDiff(oldraw)
 				if err != nil {
 					return nil, err
 				}
-				p.Diff = diff;
-				break;
+				p.Diff = diff
+				break
 			}
 			if hasPrefix(l, "index ") || hasPrefix(l, "GIT binary patch") {
-				diff, err := ParseGitBinary(oldraw);
+				diff, err := ParseGitBinary(oldraw)
 				if err != nil {
 					return nil, err
 				}
-				p.Diff = diff;
-				break;
+				p.Diff = diff
+				break
 			}
-			return nil, SyntaxError("unexpected patch header line: " + string(l));
+			return nil, SyntaxError("unexpected patch header line: " + string(l))
 		}
 		if p.Diff == nil {
 			p.Diff = NoDiff
@@ -225,25 +225,25 @@ func Parse(text []byte) (*Set, os.Error) {
 		}
 	}
 
-	return set, nil;
+	return set, nil
 }
 
 // getLine returns the first n lines of data and the remainder.
 // If data has no newline, getLine returns data, nil, false
 func getLine(data []byte, n int) (first []byte, rest []byte, ok bool) {
-	rest = data;
-	ok = true;
+	rest = data
+	ok = true
 	for ; n > 0; n-- {
-		nl := bytes.Index(rest, newline);
+		nl := bytes.Index(rest, newline)
 		if nl < 0 {
-			rest = nil;
-			ok = false;
-			break;
+			rest = nil
+			ok = false
+			break
 		}
-		rest = rest[nl+1:];
+		rest = rest[nl+1:]
 	}
-	first = data[0 : len(data)-len(rest)];
-	return;
+	first = data[0 : len(data)-len(rest)]
+	return
 }
 
 // sections returns a collection of file sections,
@@ -251,34 +251,34 @@ func getLine(data []byte, n int) (first []byte, rest []byte, ok bool) {
 // text before the first instance of such a line is
 // returned separately.
 func sections(text []byte, prefix string) ([]byte, [][]byte) {
-	n := 0;
+	n := 0
 	for b := text; ; {
 		if hasPrefix(b, prefix) {
 			n++
 		}
-		nl := bytes.Index(b, newline);
+		nl := bytes.Index(b, newline)
 		if nl < 0 {
 			break
 		}
-		b = b[nl+1:];
+		b = b[nl+1:]
 	}
 
-	sect := make([][]byte, n+1);
-	n = 0;
+	sect := make([][]byte, n+1)
+	n = 0
 	for b := text; ; {
 		if hasPrefix(b, prefix) {
-			sect[n] = text[0 : len(text)-len(b)];
-			n++;
-			text = b;
+			sect[n] = text[0 : len(text)-len(b)]
+			n++
+			text = b
 		}
-		nl := bytes.Index(b, newline);
+		nl := bytes.Index(b, newline)
 		if nl < 0 {
-			sect[n] = text;
-			break;
+			sect[n] = text
+			break
 		}
-		b = b[nl+1:];
+		b = b[nl+1:]
 	}
-	return sect[0], sect[1:];
+	return sect[0], sect[1:]
 }
 
 // if s begins with the prefix t, skip returns
@@ -287,7 +287,7 @@ func skip(s []byte, t string) (ss []byte, ok bool) {
 	if len(s) < len(t) || string(s[0:len(t)]) != t {
 		return nil, false
 	}
-	return s[len(t):], true;
+	return s[len(t):], true
 }
 
 // if s begins with the prefix t and then is a sequence
@@ -298,22 +298,22 @@ func atoi(s []byte, t string, base int) (n int, ss []byte, ok bool) {
 	if s, ok = skip(s, t); !ok {
 		return
 	}
-	var i int;
+	var i int
 	for i = 0; i < len(s) && '0' <= s[i] && s[i] <= byte('0'+base-1); i++ {
 		n = n*base + int(s[i]-'0')
 	}
 	if i == 0 {
 		return
 	}
-	return n, s[i:], true;
+	return n, s[i:], true
 }
 
 // hasPrefix returns true if s begins with t.
 func hasPrefix(s []byte, t string) bool {
-	_, ok := skip(s, t);
-	return ok;
+	_, ok := skip(s, t)
+	return ok
 }
 
 // splitLines returns the result of splitting s into lines.
 // The \n on each line is preserved.
-func splitLines(s []byte) [][]byte	{ return bytes.SplitAfter(s, newline, 0) }
+func splitLines(s []byte) [][]byte { return bytes.SplitAfter(s, newline, 0) }