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, 100 insertions, 100 deletions

diff --git a/src/pkg/bytes/bytes.go b/src/pkg/bytes/bytes.go
index 85d4f9fd7..0a2146413 100644
--- a/src/pkg/bytes/bytes.go
+++ b/src/pkg/bytes/bytes.go
@@ -7,8 +7,8 @@
 package bytes
 
 import (
-	"unicode";
-	"utf8";
+	"unicode"
+	"utf8"
 )
 
 // Compare returns an integer comparing the two byte arrays lexicographically.
@@ -28,7 +28,7 @@ func Compare(a, b []byte) int {
 	case len(a) > len(b):
 		return 1
 	}
-	return 0;
+	return 0
 }
 
 // Equal returns a boolean reporting whether a == b.
@@ -41,7 +41,7 @@ func Equal(a, b []byte) bool {
 			return false
 		}
 	}
-	return true;
+	return true
 }
 
 // explode splits s into an array of UTF-8 sequences, one per Unicode character (still arrays of bytes),
@@ -50,21 +50,21 @@ func explode(s []byte, n int) [][]byte {
 	if n <= 0 {
 		n = len(s)
 	}
-	a := make([][]byte, n);
-	var size int;
-	na := 0;
+	a := make([][]byte, n)
+	var size int
+	na := 0
 	for len(s) > 0 {
 		if na+1 >= n {
-			a[na] = s;
-			na++;
-			break;
+			a[na] = s
+			na++
+			break
 		}
-		_, size = utf8.DecodeRune(s);
-		a[na] = s[0:size];
-		s = s[size:];
-		na++;
+		_, size = utf8.DecodeRune(s)
+		a[na] = s[0:size]
+		s = s[size:]
+		na++
 	}
-	return a[0:na];
+	return a[0:na]
 }
 
 // Count counts the number of non-overlapping instances of sep in s.
@@ -72,34 +72,34 @@ func Count(s, sep []byte) int {
 	if len(sep) == 0 {
 		return utf8.RuneCount(s) + 1
 	}
-	c := sep[0];
-	n := 0;
+	c := sep[0]
+	n := 0
 	for i := 0; i+len(sep) <= len(s); i++ {
 		if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) {
-			n++;
-			i += len(sep) - 1;
+			n++
+			i += len(sep) - 1
 		}
 	}
-	return n;
+	return n
 }
 
 // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
 func Index(s, sep []byte) int {
-	n := len(sep);
+	n := len(sep)
 	if n == 0 {
 		return 0
 	}
-	c := sep[0];
+	c := sep[0]
 	for i := 0; i+n <= len(s); i++ {
 		if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) {
 			return i
 		}
 	}
-	return -1;
+	return -1
 }
 
 // IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
-func IndexByte(s []byte, c byte) int	// asm_$GOARCH.s
+func IndexByte(s []byte, c byte) int // asm_$GOARCH.s
 
 func indexBytePortable(s []byte, c byte) int {
 	for i, b := range s {
@@ -107,22 +107,22 @@ func indexBytePortable(s []byte, c byte) int {
 			return i
 		}
 	}
-	return -1;
+	return -1
 }
 
 // LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.
 func LastIndex(s, sep []byte) int {
-	n := len(sep);
+	n := len(sep)
 	if n == 0 {
 		return len(s)
 	}
-	c := sep[0];
+	c := sep[0]
 	for i := len(s) - n; i >= 0; i-- {
 		if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) {
 			return i
 		}
 	}
-	return -1;
+	return -1
 }
 
 // Generic split: splits after each instance of sep,
@@ -134,26 +134,26 @@ func genSplit(s, sep []byte, sepSave, n int) [][]byte {
 	if n <= 0 {
 		n = Count(s, sep) + 1
 	}
-	c := sep[0];
-	start := 0;
-	a := make([][]byte, n);
-	na := 0;
+	c := sep[0]
+	start := 0
+	a := make([][]byte, n)
+	na := 0
 	for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
 		if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) {
-			a[na] = s[start : i+sepSave];
-			na++;
-			start = i + len(sep);
-			i += len(sep) - 1;
+			a[na] = s[start : i+sepSave]
+			na++
+			start = i + len(sep)
+			i += len(sep) - 1
 		}
 	}
-	a[na] = s[start:];
-	return a[0 : na+1];
+	a[na] = s[start:]
+	return a[0 : na+1]
 }
 
 // Split splits the array s around each instance of sep, returning an array of subarrays of s.
 // If sep is empty, Split splits s after each UTF-8 sequence.
 // If n > 0, Split splits s into at most n subarrays; the last subarray will contain an unsplit remainder.
-func Split(s, sep []byte, n int) [][]byte	{ return genSplit(s, sep, 0, n) }
+func Split(s, sep []byte, n int) [][]byte { return genSplit(s, sep, 0, n) }
 
 // SplitAfter splits the array s after each instance of sep, returning an array of subarrays of s.
 // If sep is empty, SplitAfter splits s after each UTF-8 sequence.
@@ -172,28 +172,28 @@ func Join(a [][]byte, sep []byte) []byte {
 	if len(a) == 1 {
 		return a[0]
 	}
-	n := len(sep) * (len(a) - 1);
+	n := len(sep) * (len(a) - 1)
 	for i := 0; i < len(a); i++ {
 		n += len(a[i])
 	}
 
-	b := make([]byte, n);
-	bp := 0;
+	b := make([]byte, n)
+	bp := 0
 	for i := 0; i < len(a); i++ {
-		s := a[i];
+		s := a[i]
 		for j := 0; j < len(s); j++ {
-			b[bp] = s[j];
-			bp++;
+			b[bp] = s[j]
+			bp++
 		}
 		if i+1 < len(a) {
-			s = sep;
+			s = sep
 			for j := 0; j < len(s); j++ {
-				b[bp] = s[j];
-				bp++;
+				b[bp] = s[j]
+				bp++
 			}
 		}
 	}
-	return b;
+	return b
 }
 
 // HasPrefix tests whether the byte array s begins with prefix.
@@ -213,88 +213,88 @@ func Map(mapping func(rune int) int, s []byte) []byte {
 	// In the worst case, the array can grow when mapped, making
 	// things unpleasant.  But it's so rare we barge in assuming it's
 	// fine.  It could also shrink but that falls out naturally.
-	maxbytes := len(s);	// length of b
-	nbytes := 0;		// number of bytes encoded in b
-	b := make([]byte, maxbytes);
+	maxbytes := len(s) // length of b
+	nbytes := 0        // number of bytes encoded in b
+	b := make([]byte, maxbytes)
 	for i := 0; i < len(s); {
-		wid := 1;
-		rune := int(s[i]);
+		wid := 1
+		rune := int(s[i])
 		if rune >= utf8.RuneSelf {
 			rune, wid = utf8.DecodeRune(s[i:])
 		}
-		rune = mapping(rune);
+		rune = mapping(rune)
 		if rune >= 0 {
 			if nbytes+utf8.RuneLen(rune) > maxbytes {
 				// Grow the buffer.
-				maxbytes = maxbytes*2 + utf8.UTFMax;
-				nb := make([]byte, maxbytes);
+				maxbytes = maxbytes*2 + utf8.UTFMax
+				nb := make([]byte, maxbytes)
 				for i, c := range b[0:nbytes] {
 					nb[i] = c
 				}
-				b = nb;
+				b = nb
 			}
-			nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes]);
+			nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes])
 		}
-		i += wid;
+		i += wid
 	}
-	return b[0:nbytes];
+	return b[0:nbytes]
 }
 
 // Repeat returns a new byte array consisting of count copies of b.
 func Repeat(b []byte, count int) []byte {
-	nb := make([]byte, len(b)*count);
-	bp := 0;
+	nb := make([]byte, len(b)*count)
+	bp := 0
 	for i := 0; i < count; i++ {
 		for j := 0; j < len(b); j++ {
-			nb[bp] = b[j];
-			bp++;
+			nb[bp] = b[j]
+			bp++
 		}
 	}
-	return nb;
+	return nb
 }
 
 // ToUpper returns a copy of the byte array s with all Unicode letters mapped to their upper case.
-func ToUpper(s []byte) []byte	{ return Map(unicode.ToUpper, s) }
+func ToUpper(s []byte) []byte { return Map(unicode.ToUpper, s) }
 
 // ToUpper returns a copy of the byte array s with all Unicode letters mapped to their lower case.
-func ToLower(s []byte) []byte	{ return Map(unicode.ToLower, s) }
+func ToLower(s []byte) []byte { return Map(unicode.ToLower, s) }
 
 // ToTitle returns a copy of the byte array s with all Unicode letters mapped to their title case.
-func ToTitle(s []byte) []byte	{ return Map(unicode.ToTitle, s) }
+func ToTitle(s []byte) []byte { return Map(unicode.ToTitle, s) }
 
 // Trim returns a slice of the string s, with all leading and trailing white space
 // removed, as defined by Unicode.
 func TrimSpace(s []byte) []byte {
-	start, end := 0, len(s);
+	start, end := 0, len(s)
 	for start < end {
-		wid := 1;
-		rune := int(s[start]);
+		wid := 1
+		rune := int(s[start])
 		if rune >= utf8.RuneSelf {
 			rune, wid = utf8.DecodeRune(s[start:end])
 		}
 		if !unicode.IsSpace(rune) {
 			break
 		}
-		start += wid;
+		start += wid
 	}
 	for start < end {
-		wid := 1;
-		rune := int(s[end-1]);
+		wid := 1
+		rune := int(s[end-1])
 		if rune >= utf8.RuneSelf {
 			// Back up carefully looking for beginning of rune. Mustn't pass start.
 			for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ {
 			}
-			if start > end-wid {	// invalid UTF-8 sequence; stop processing
+			if start > end-wid { // invalid UTF-8 sequence; stop processing
 				return s[start:end]
 			}
-			rune, wid = utf8.DecodeRune(s[end-wid : end]);
+			rune, wid = utf8.DecodeRune(s[end-wid : end])
 		}
 		if !unicode.IsSpace(rune) {
 			break
 		}
-		end -= wid;
+		end -= wid
 	}
-	return s[start:end];
+	return s[start:end]
 }
 
 // How big to make a byte array when growing.
@@ -303,51 +303,51 @@ func resize(n int) int {
 	if n < 16 {
 		n = 16
 	}
-	return n + n/2;
+	return n + n/2
 }
 
 // Add appends the contents of t to the end of s and returns the result.
 // If s has enough capacity, it is extended in place; otherwise a
 // new array is allocated and returned.
 func Add(s, t []byte) []byte {
-	lens := len(s);
-	lent := len(t);
+	lens := len(s)
+	lent := len(t)
 	if lens+lent <= cap(s) {
 		s = s[0 : lens+lent]
 	} else {
-		news := make([]byte, lens+lent, resize(lens+lent));
-		copy(news, s);
-		s = news;
+		news := make([]byte, lens+lent, resize(lens+lent))
+		copy(news, s)
+		s = news
 	}
-	copy(s[lens:lens+lent], t);
-	return s;
+	copy(s[lens:lens+lent], t)
+	return s
 }
 
 // AddByte appends byte b to the end of s and returns the result.
 // If s has enough capacity, it is extended in place; otherwise a
 // new array is allocated and returned.
 func AddByte(s []byte, t byte) []byte {
-	lens := len(s);
+	lens := len(s)
 	if lens+1 <= cap(s) {
 		s = s[0 : lens+1]
 	} else {
-		news := make([]byte, lens+1, resize(lens+1));
-		copy(news, s);
-		s = news;
+		news := make([]byte, lens+1, resize(lens+1))
+		copy(news, s)
+		s = news
 	}
-	s[lens] = t;
-	return s;
+	s[lens] = t
+	return s
 }
 
 // Runes returns a slice of runes (Unicode code points) equivalent to s.
 func Runes(s []byte) []int {
-	t := make([]int, utf8.RuneCount(s));
-	i := 0;
+	t := make([]int, utf8.RuneCount(s))
+	i := 0
 	for len(s) > 0 {
-		r, l := utf8.DecodeRune(s);
-		t[i] = r;
-		i++;
-		s = s[l:];
+		r, l := utf8.DecodeRune(s)
+		t[i] = r
+		i++
+		s = s[l:]
 	}
-	return t;
+	return t
 }