another round of gofmt applications

R=gri
DELTA=900  (106 added, 31 deleted, 763 changed)
OCL=35384
CL=35396

src/pkg/bytes/bytes.go

@@ -17,31 +17,31 @@ func Compare(a, b []byte) int {
 	for i := 0; i < len(a) && i < len(b); i++ {
 		switch {
 		case a[i] > b[i]:
-			return 1
+			return 1;
 		case a[i] < b[i]:
-			return -1
+			return -1;
 		}
 	}
 	switch {
 	case len(a) < len(b):
-		return -1
+		return -1;
 	case len(a) > len(b):
-		return 1
+		return 1;
 	}
-	return 0
+	return 0;
 }
 
 // Equal returns a boolean reporting whether a == b.
 func Equal(a, b []byte) bool {
 	if len(a) != len(b) {
-		return false
+		return false;
 	}
 	for i := 0; i < len(a); i++ {
 		if a[i] != b[i] {
-			return false
+			return false;
 		}
 	}
-	return true
+	return true;
 }
 
 // Copy copies bytes from src to dst,
@@ -53,9 +53,9 @@ func Copy(dst, src []byte) int {
 		src = src[0:len(dst)];
 	}
 	for i, x := range src {
-		dst[i] = x
+		dst[i] = x;
 	}
-	return len(src)
+	return len(src);
 }
 
 // explode splits s into an array of UTF-8 sequences, one per Unicode character (still arrays of bytes),
@@ -71,45 +71,45 @@ func explode(s []byte, n int) [][]byte {
 		if na+1 >= n {
 			a[na] = s;
 			na++;
-			break
+			break;
 		}
 		_, size = utf8.DecodeRune(s);
 		a[na] = s[0:size];
 		s = s[size:len(s)];
 		na++;
 	}
-	return a[0:na]
+	return a[0:na];
 }
 
 // Count counts the number of non-overlapping instances of sep in s.
 func Count(s, sep []byte) int {
 	if len(sep) == 0 {
-		return utf8.RuneCount(s)+1
+		return utf8.RuneCount(s) + 1;
 	}
 	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)) {
+		if s[i] == c && (len(sep) == 1 || Equal(s[i : i+len(sep)], sep)) {
 			n++;
-			i += len(sep)-1
+			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);
 	if n == 0 {
-		return 0
+		return 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
+		if s[i] == c && (n == 1 || Equal(s[i : i+n], sep)) {
+			return i;
 		}
 	}
-	return -1
+	return -1;
 }
 
 // Split splits the array s around each instance of sep, returning an array of subarrays of s.
@@ -117,7 +117,7 @@ func Index(s, sep []byte) int {
 // 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 {
 	if len(sep) == 0 {
-		return explode(s, n)
+		return explode(s, n);
 	}
 	if n <= 0 {
 		n = Count(s, sep) + 1;
@@ -127,7 +127,7 @@ func Split(s, sep []byte, n int) [][]byte {
 	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)) {
+		if s[i] == c && (len(sep) == 1 || Equal(s[i : i+len(sep)], sep)) {
 			a[na] = s[start:i];
 			na++;
 			start = i+len(sep);
@@ -135,21 +135,21 @@ func Split(s, sep []byte, n int) [][]byte {
 		}
 	}
 	a[na] = s[start:len(s)];
-	return a[0:na+1]
+	return a[0 : na+1];
 }
 
 // Join concatenates the elements of a to create a single byte array.   The separator
 // sep is placed between elements in the resulting array.
 func Join(a [][]byte, sep []byte) []byte {
 	if len(a) == 0 {
-		return []byte{}
+		return []byte{};
 	}
 	if len(a) == 1 {
-		return a[0]
+		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])
+		n += len(a[i]);
 	}
 
 	b := make([]byte, n);
@@ -158,27 +158,27 @@ func Join(a [][]byte, sep []byte) []byte {
 		s := a[i];
 		for j := 0; j < len(s); j++ {
 			b[bp] = s[j];
-			bp++
+			bp++;
 		}
-		if i + 1 < len(a) {
+		if i+1 < len(a) {
 			s = sep;
 			for j := 0; j < len(s); j++ {
 				b[bp] = s[j];
-				bp++
+				bp++;
 			}
 		}
 	}
-	return b
+	return b;
 }
 
 // HasPrefix tests whether the byte array s begins with prefix.
 func HasPrefix(s, prefix []byte) bool {
-	return len(s) >= len(prefix) && Equal(s[0:len(prefix)], prefix)
+	return len(s) >= len(prefix) && Equal(s[0:len(prefix)], prefix);
 }
 
 // HasSuffix tests whether the byte array s ends with suffix.
 func HasSuffix(s, suffix []byte) bool {
-	return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix):len(s)], suffix)
+	return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix) : len(s)], suffix);
 }
 
 // Map returns a copy of the byte array s with all its characters modified
@@ -188,7 +188,7 @@ func Map(mapping func(rune int) int, s []byte) []byte {
 	// 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
+	nbytes := 0;		// number of bytes encoded in b
 	b := make([]byte, maxbytes);
 	for i := 0; i < len(s); {
 		wid := 1;
@@ -204,7 +204,7 @@ func Map(mapping func(rune int) int, s []byte) []byte {
 			maxbytes = maxbytes*2 + utf8.UTFMax;
 			nb := make([]byte, maxbytes);
 			for i, c := range b[0:nbytes] {
-				nb[i] = c
+				nb[i] = c;
 			}
 			b = nb;
 		}
@@ -216,17 +216,17 @@ func Map(mapping func(rune int) int, s []byte) []byte {
 
 // 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)
+	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)
+	return Map(unicode.ToLower, s);
 }
 
 // ToTitle returns a copy of the byte array s with all Unicode letters mapped to their title case.
 func Title(s []byte) []byte {
-	return Map(unicode.ToTitle, s)
+	return Map(unicode.ToTitle, s);
 }
 
 // Trim returns a slice of the string s, with all leading and trailing white space
@@ -237,7 +237,7 @@ func TrimSpace(s []byte) []byte {
 		wid := 1;
 		rune := int(s[start]);
 		if rune >= utf8.RuneSelf {
-			rune, wid = utf8.DecodeRune(s[start:end])
+			rune, wid = utf8.DecodeRune(s[start:end]);
 		}
 		if !unicode.IsSpace(rune) {
 			break;
@@ -249,12 +249,11 @@ func TrimSpace(s []byte) []byte {
 		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++ {
-			}
+			for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ {}
 			if start > end-wid {	// invalid UTF-8 sequence; stop processing
-				return s[start:end]
+				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;
@@ -268,7 +267,7 @@ func TrimSpace(s []byte) []byte {
 // Heuristic: Scale by 50% to give n log n time.
 func resize(n int) int {
 	if n < 16 {
-		n = 16
+		n = 16;
 	}
 	return n + n/2;
 }
@@ -279,14 +278,14 @@ func resize(n int) int {
 func Add(s, t []byte) []byte {
 	lens := len(s);
 	lent := len(t);
-	if lens + lent <= cap(s) {
-		s = s[0:lens+lent];
+	if lens+lent <= cap(s) {
+		s = s[0 : lens+lent];
 	} else {
 		news := make([]byte, lens+lent, resize(lens+lent));
 		Copy(news, s);
 		s = news;
 	}
-	Copy(s[lens:lens+lent], t);
+	Copy(s[lens : lens+lent], t);
 	return s;
 }
 
@@ -295,8 +294,8 @@ func Add(s, t []byte) []byte {
 // new array is allocated and returned.
 func AddByte(s []byte, t byte) []byte {
 	lens := len(s);
-	if lens + 1 <= cap(s) {
-		s = s[0:lens+1];
+	if lens+1 <= cap(s) {
+		s = s[0 : lens+1];
 	} else {
 		news := make([]byte, lens+1, resize(lens+1));
 		Copy(news, s);