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

	       2nd set of files.

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

1 files changed, 138 insertions, 138 deletions

diff --git a/src/pkg/fmt/format.go b/src/pkg/fmt/format.go
index b53bcc5a6..38b234414 100644
--- a/src/pkg/fmt/format.go
+++ b/src/pkg/fmt/format.go
@@ -5,20 +5,20 @@
 package fmt
 
 import (
-	"bytes";
-	"strconv";
+	"bytes"
+	"strconv"
 )
 
 const (
-	nByte	= 64;
+	nByte = 64
 
-	ldigits	= "0123456789abcdef";
-	udigits	= "0123456789ABCDEF";
+	ldigits = "0123456789abcdef"
+	udigits = "0123456789ABCDEF"
 )
 
 const (
-	signed		= true;
-	unsigned	= false;
+	signed   = true
+	unsigned = false
 )
 
 var padZeroBytes = make([]byte, nByte)
@@ -28,55 +28,55 @@ var newline = []byte{'\n'}
 
 func init() {
 	for i := 0; i < nByte; i++ {
-		padZeroBytes[i] = '0';
-		padSpaceBytes[i] = ' ';
+		padZeroBytes[i] = '0'
+		padSpaceBytes[i] = ' '
 	}
 }
 
 // A fmt is the raw formatter used by Printf etc.
 // It prints into a bytes.Buffer that must be set up externally.
 type fmt struct {
-	intbuf	[nByte]byte;
-	buf	*bytes.Buffer;
+	intbuf [nByte]byte
+	buf    *bytes.Buffer
 	// width, precision
-	wid	int;
-	prec	int;
+	wid  int
+	prec int
 	// flags
-	widPresent	bool;
-	precPresent	bool;
-	minus		bool;
-	plus		bool;
-	sharp		bool;
-	space		bool;
-	zero		bool;
+	widPresent  bool
+	precPresent bool
+	minus       bool
+	plus        bool
+	sharp       bool
+	space       bool
+	zero        bool
 }
 
 func (f *fmt) clearflags() {
-	f.wid = 0;
-	f.widPresent = false;
-	f.prec = 0;
-	f.precPresent = false;
-	f.minus = false;
-	f.plus = false;
-	f.sharp = false;
-	f.space = false;
-	f.zero = false;
+	f.wid = 0
+	f.widPresent = false
+	f.prec = 0
+	f.precPresent = false
+	f.minus = false
+	f.plus = false
+	f.sharp = false
+	f.space = false
+	f.zero = false
 }
 
 func (f *fmt) init(buf *bytes.Buffer) {
-	f.buf = buf;
-	f.clearflags();
+	f.buf = buf
+	f.clearflags()
 }
 
 // Compute left and right padding widths (only one will be non-zero).
 func (f *fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth int) {
-	left := !f.minus;
-	w := f.wid;
+	left := !f.minus
+	w := f.wid
 	if w < 0 {
-		left = false;
-		w = -w;
+		left = false
+		w = -w
 	}
-	w -= width;
+	w -= width
 	if w > 0 {
 		if left && f.zero {
 			return padZeroBytes, w, 0
@@ -88,66 +88,66 @@ func (f *fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth i
 			return padSpaceBytes, 0, w
 		}
 	}
-	return;
+	return
 }
 
 // Generate n bytes of padding.
 func (f *fmt) writePadding(n int, padding []byte) {
 	for n > 0 {
-		m := n;
+		m := n
 		if m > nByte {
 			m = nByte
 		}
-		f.buf.Write(padding[0:m]);
-		n -= m;
+		f.buf.Write(padding[0:m])
+		n -= m
 	}
 }
 
 // Append b to f.buf, padded on left (w > 0) or right (w < 0 or f.minus)
 // clear flags aftewards.
 func (f *fmt) pad(b []byte) {
-	var padding []byte;
-	var left, right int;
+	var padding []byte
+	var left, right int
 	if f.widPresent && f.wid != 0 {
 		padding, left, right = f.computePadding(len(b))
 	}
 	if left > 0 {
 		f.writePadding(left, padding)
 	}
-	f.buf.Write(b);
+	f.buf.Write(b)
 	if right > 0 {
 		f.writePadding(right, padding)
 	}
-	f.clearflags();
+	f.clearflags()
 }
 
 // append s to buf, padded on left (w > 0) or right (w < 0 or f.minus).
 // clear flags aftewards.
 func (f *fmt) padString(s string) {
-	var padding []byte;
-	var left, right int;
+	var padding []byte
+	var left, right int
 	if f.widPresent && f.wid != 0 {
 		padding, left, right = f.computePadding(len(s))
 	}
 	if left > 0 {
 		f.writePadding(left, padding)
 	}
-	f.buf.WriteString(s);
+	f.buf.WriteString(s)
 	if right > 0 {
 		f.writePadding(right, padding)
 	}
-	f.clearflags();
+	f.clearflags()
 }
 
 func putint(buf []byte, base, val uint64, digits string) int {
-	i := len(buf) - 1;
+	i := len(buf) - 1
 	for val >= base {
-		buf[i] = digits[val%base];
-		i--;
-		val /= base;
+		buf[i] = digits[val%base]
+		i--
+		val /= base
 	}
-	buf[i] = digits[val];
-	return i - 1;
+	buf[i] = digits[val]
+	return i - 1
 }
 
 // fmt_boolean formats a boolean.
@@ -162,22 +162,22 @@ func (f *fmt) fmt_boolean(v bool) {
 // integer; interprets prec but not wid.  Once formatted, result is sent to pad()
 // and then flags are cleared.
 func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) {
-	var buf []byte = &f.intbuf;
-	negative := signedness == signed && a < 0;
+	var buf []byte = &f.intbuf
+	negative := signedness == signed && a < 0
 	if negative {
 		a = -a
 	}
 
 	// two ways to ask for extra leading zero digits: %.3d or %03d.
 	// apparently the first cancels the second.
-	prec := 0;
+	prec := 0
 	if f.precPresent {
-		prec = f.prec;
-		f.zero = false;
+		prec = f.prec
+		f.zero = false
 	} else if f.zero && f.widPresent && !f.minus && f.wid > 0 {
-		prec = f.wid;
+		prec = f.wid
 		if negative || f.plus || f.space {
-			prec--	// leave room for sign
+			prec-- // leave room for sign
 		}
 	}
 
@@ -185,18 +185,18 @@ func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) {
 	// a is made into unsigned ua.  we could make things
 	// marginally faster by splitting the 32-bit case out into a separate
 	// block but it's not worth the duplication, so ua has 64 bits.
-	i := len(f.intbuf);
-	ua := uint64(a);
+	i := len(f.intbuf)
+	ua := uint64(a)
 	for ua >= base {
-		i--;
-		buf[i] = digits[ua%base];
-		ua /= base;
+		i--
+		buf[i] = digits[ua%base]
+		ua /= base
 	}
-	i--;
-	buf[i] = digits[ua];
+	i--
+	buf[i] = digits[ua]
 	for i > 0 && prec > nByte-i {
-		i--;
-		buf[i] = '0';
+		i--
+		buf[i] = '0'
 	}
 
 	// Various prefixes: 0x, -, etc.
@@ -204,113 +204,113 @@ func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) {
 		switch base {
 		case 8:
 			if buf[i] != '0' {
-				i--;
-				buf[i] = '0';
+				i--
+				buf[i] = '0'
 			}
 		case 16:
-			i--;
-			buf[i] = 'x' + digits[10] - 'a';
-			i--;
-			buf[i] = '0';
+			i--
+			buf[i] = 'x' + digits[10] - 'a'
+			i--
+			buf[i] = '0'
 		}
 	}
 
 	if negative {
-		i--;
-		buf[i] = '-';
+		i--
+		buf[i] = '-'
 	} else if f.plus {
-		i--;
-		buf[i] = '+';
+		i--
+		buf[i] = '+'
 	} else if f.space {
-		i--;
-		buf[i] = ' ';
+		i--
+		buf[i] = ' '
 	}
-	f.pad(buf[i:]);
+	f.pad(buf[i:])
 }
 
 // fmt_d64 formats an int64 in decimal.
-func (f *fmt) fmt_d64(v int64)	{ f.integer(v, 10, signed, ldigits) }
+func (f *fmt) fmt_d64(v int64) { f.integer(v, 10, signed, ldigits) }
 
 // fmt_d32 formats an int32 in decimal.
-func (f *fmt) fmt_d32(v int32)	{ f.integer(int64(v), 10, signed, ldigits) }
+func (f *fmt) fmt_d32(v int32) { f.integer(int64(v), 10, signed, ldigits) }
 
 // fmt_d formats an int in decimal.
-func (f *fmt) fmt_d(v int)	{ f.integer(int64(v), 10, signed, ldigits) }
+func (f *fmt) fmt_d(v int) { f.integer(int64(v), 10, signed, ldigits) }
 
 // fmt_ud64 formats a uint64 in decimal.
-func (f *fmt) fmt_ud64(v uint64)	{ f.integer(int64(v), 10, unsigned, ldigits) }
+func (f *fmt) fmt_ud64(v uint64) { f.integer(int64(v), 10, unsigned, ldigits) }
 
 // fmt_ud32 formats a uint32 in decimal.
-func (f *fmt) fmt_ud32(v uint32)	{ f.integer(int64(v), 10, unsigned, ldigits) }
+func (f *fmt) fmt_ud32(v uint32) { f.integer(int64(v), 10, unsigned, ldigits) }
 
 // fmt_ud formats a uint in decimal.
-func (f *fmt) fmt_ud(v uint)	{ f.integer(int64(v), 10, unsigned, ldigits) }
+func (f *fmt) fmt_ud(v uint) { f.integer(int64(v), 10, unsigned, ldigits) }
 
 // fmt_x64 formats an int64 in hexadecimal.
-func (f *fmt) fmt_x64(v int64)	{ f.integer(v, 16, signed, ldigits) }
+func (f *fmt) fmt_x64(v int64) { f.integer(v, 16, signed, ldigits) }
 
 // fmt_x32 formats an int32 in hexadecimal.
-func (f *fmt) fmt_x32(v int32)	{ f.integer(int64(v), 16, signed, ldigits) }
+func (f *fmt) fmt_x32(v int32) { f.integer(int64(v), 16, signed, ldigits) }
 
 // fmt_x formats an int in hexadecimal.
-func (f *fmt) fmt_x(v int)	{ f.integer(int64(v), 16, signed, ldigits) }
+func (f *fmt) fmt_x(v int) { f.integer(int64(v), 16, signed, ldigits) }
 
 // fmt_ux64 formats a uint64 in hexadecimal.
-func (f *fmt) fmt_ux64(v uint64)	{ f.integer(int64(v), 16, unsigned, ldigits) }
+func (f *fmt) fmt_ux64(v uint64) { f.integer(int64(v), 16, unsigned, ldigits) }
 
 // fmt_ux32 formats a uint32 in hexadecimal.
-func (f *fmt) fmt_ux32(v uint32)	{ f.integer(int64(v), 16, unsigned, ldigits) }
+func (f *fmt) fmt_ux32(v uint32) { f.integer(int64(v), 16, unsigned, ldigits) }
 
 // fmt_ux formats a uint in hexadecimal.
-func (f *fmt) fmt_ux(v uint)	{ f.integer(int64(v), 16, unsigned, ldigits) }
+func (f *fmt) fmt_ux(v uint) { f.integer(int64(v), 16, unsigned, ldigits) }
 
 // fmt_X64 formats an int64 in upper case hexadecimal.
-func (f *fmt) fmt_X64(v int64)	{ f.integer(v, 16, signed, udigits) }
+func (f *fmt) fmt_X64(v int64) { f.integer(v, 16, signed, udigits) }
 
 // fmt_X32 formats an int32 in upper case hexadecimal.
-func (f *fmt) fmt_X32(v int32)	{ f.integer(int64(v), 16, signed, udigits) }
+func (f *fmt) fmt_X32(v int32) { f.integer(int64(v), 16, signed, udigits) }
 
 // fmt_X formats an int in upper case hexadecimal.
-func (f *fmt) fmt_X(v int)	{ f.integer(int64(v), 16, signed, udigits) }
+func (f *fmt) fmt_X(v int) { f.integer(int64(v), 16, signed, udigits) }
 
 // fmt_uX64 formats a uint64 in upper case hexadecimal.
-func (f *fmt) fmt_uX64(v uint64)	{ f.integer(int64(v), 16, unsigned, udigits) }
+func (f *fmt) fmt_uX64(v uint64) { f.integer(int64(v), 16, unsigned, udigits) }
 
 // fmt_uX32 formats a uint32 in upper case hexadecimal.
-func (f *fmt) fmt_uX32(v uint32)	{ f.integer(int64(v), 16, unsigned, udigits) }
+func (f *fmt) fmt_uX32(v uint32) { f.integer(int64(v), 16, unsigned, udigits) }
 
 // fmt_uX formats a uint in upper case hexadecimal.
-func (f *fmt) fmt_uX(v uint)	{ f.integer(int64(v), 16, unsigned, udigits) }
+func (f *fmt) fmt_uX(v uint) { f.integer(int64(v), 16, unsigned, udigits) }
 
 // fmt_o64 formats an int64 in octal.
-func (f *fmt) fmt_o64(v int64)	{ f.integer(v, 8, signed, ldigits) }
+func (f *fmt) fmt_o64(v int64) { f.integer(v, 8, signed, ldigits) }
 
 // fmt_o32 formats an int32 in octal.
-func (f *fmt) fmt_o32(v int32)	{ f.integer(int64(v), 8, signed, ldigits) }
+func (f *fmt) fmt_o32(v int32) { f.integer(int64(v), 8, signed, ldigits) }
 
 // fmt_o formats an int in octal.
-func (f *fmt) fmt_o(v int)	{ f.integer(int64(v), 8, signed, ldigits) }
+func (f *fmt) fmt_o(v int) { f.integer(int64(v), 8, signed, ldigits) }
 
 // fmt_uo64 formats a uint64 in octal.
-func (f *fmt) fmt_uo64(v uint64)	{ f.integer(int64(v), 8, unsigned, ldigits) }
+func (f *fmt) fmt_uo64(v uint64) { f.integer(int64(v), 8, unsigned, ldigits) }
 
 // fmt_uo32 formats a uint32 in octal.
-func (f *fmt) fmt_uo32(v uint32)	{ f.integer(int64(v), 8, unsigned, ldigits) }
+func (f *fmt) fmt_uo32(v uint32) { f.integer(int64(v), 8, unsigned, ldigits) }
 
 // fmt_uo formats a uint in octal.
-func (f *fmt) fmt_uo(v uint)	{ f.integer(int64(v), 8, unsigned, ldigits) }
+func (f *fmt) fmt_uo(v uint) { f.integer(int64(v), 8, unsigned, ldigits) }
 
 // fmt_b64 formats a uint64 in binary.
-func (f *fmt) fmt_b64(v uint64)	{ f.integer(int64(v), 2, unsigned, ldigits) }
+func (f *fmt) fmt_b64(v uint64) { f.integer(int64(v), 2, unsigned, ldigits) }
 
 // fmt_b32 formats a uint32 in binary.
-func (f *fmt) fmt_b32(v uint32)	{ f.integer(int64(v), 2, unsigned, ldigits) }
+func (f *fmt) fmt_b32(v uint32) { f.integer(int64(v), 2, unsigned, ldigits) }
 
 // fmt_b formats a uint in binary.
-func (f *fmt) fmt_b(v uint)	{ f.integer(int64(v), 2, unsigned, ldigits) }
+func (f *fmt) fmt_b(v uint) { f.integer(int64(v), 2, unsigned, ldigits) }
 
 // fmt_c formats a Unicode character.
-func (f *fmt) fmt_c(v int)	{ f.padString(string(v)) }
+func (f *fmt) fmt_c(v int) { f.padString(string(v)) }
 
 // fmt_s formats a string.
 func (f *fmt) fmt_s(s string) {
@@ -319,43 +319,43 @@ func (f *fmt) fmt_s(s string) {
 			s = s[0:f.prec]
 		}
 	}
-	f.padString(s);
+	f.padString(s)
 }
 
 // fmt_sx formats a string as a hexadecimal encoding of its bytes.
 func (f *fmt) fmt_sx(s string) {
-	t := "";
+	t := ""
 	for i := 0; i < len(s); i++ {
 		if i > 0 && f.space {
 			t += " "
 		}
-		v := s[i];
-		t += string(ldigits[v>>4]);
-		t += string(ldigits[v&0xF]);
+		v := s[i]
+		t += string(ldigits[v>>4])
+		t += string(ldigits[v&0xF])
 	}
-	f.padString(t);
+	f.padString(t)
 }
 
 // fmt_sX formats a string as an uppercase hexadecimal encoding of its bytes.
 func (f *fmt) fmt_sX(s string) {
-	t := "";
+	t := ""
 	for i := 0; i < len(s); i++ {
-		v := s[i];
-		t += string(udigits[v>>4]);
-		t += string(udigits[v&0xF]);
+		v := s[i]
+		t += string(udigits[v>>4])
+		t += string(udigits[v&0xF])
 	}
-	f.padString(t);
+	f.padString(t)
 }
 
 // fmt_q formats a string as a double-quoted, escaped Go string constant.
 func (f *fmt) fmt_q(s string) {
-	var quoted string;
+	var quoted string
 	if f.sharp && strconv.CanBackquote(s) {
 		quoted = "`" + s + "`"
 	} else {
 		quoted = strconv.Quote(s)
 	}
-	f.padString(quoted);
+	f.padString(quoted)
 }
 
 // floating-point
@@ -364,7 +364,7 @@ func doPrec(f *fmt, def int) int {
 	if f.precPresent {
 		return f.prec
 	}
-	return def;
+	return def
 }
 
 // Add a plus sign or space to the floating-point string representation if missing and required.
@@ -376,48 +376,48 @@ func (f *fmt) plusSpace(s string) {
 			s = " " + s
 		}
 	}
-	f.padString(s);
+	f.padString(s)
 }
 
 // fmt_e64 formats a float64 in the form -1.23e+12.
-func (f *fmt) fmt_e64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) }
+func (f *fmt) fmt_e64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) }
 
 // fmt_E64 formats a float64 in the form -1.23E+12.
-func (f *fmt) fmt_E64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) }
+func (f *fmt) fmt_E64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) }
 
 // fmt_f64 formats a float64 in the form -1.23.
-func (f *fmt) fmt_f64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) }
+func (f *fmt) fmt_f64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) }
 
 // fmt_g64 formats a float64 in the 'f' or 'e' form according to size.
-func (f *fmt) fmt_g64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) }
+func (f *fmt) fmt_g64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) }
 
 // fmt_g64 formats a float64 in the 'f' or 'E' form according to size.
-func (f *fmt) fmt_G64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) }
+func (f *fmt) fmt_G64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) }
 
 // fmt_fb64 formats a float64 in the form -123p3 (exponent is power of 2).
-func (f *fmt) fmt_fb64(v float64)	{ f.plusSpace(strconv.Ftoa64(v, 'b', 0)) }
+func (f *fmt) fmt_fb64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'b', 0)) }
 
 // float32
 // cannot defer to float64 versions
 // because it will get rounding wrong in corner cases.
 
 // fmt_e32 formats a float32 in the form -1.23e+12.
-func (f *fmt) fmt_e32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) }
+func (f *fmt) fmt_e32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) }
 
 // fmt_E32 formats a float32 in the form -1.23E+12.
-func (f *fmt) fmt_E32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) }
+func (f *fmt) fmt_E32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) }
 
 // fmt_f32 formats a float32 in the form -1.23.
-func (f *fmt) fmt_f32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) }
+func (f *fmt) fmt_f32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) }
 
 // fmt_g32 formats a float32 in the 'f' or 'e' form according to size.
-func (f *fmt) fmt_g32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) }
+func (f *fmt) fmt_g32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) }
 
 // fmt_G32 formats a float32 in the 'f' or 'E' form according to size.
-func (f *fmt) fmt_G32(v float32)	{ f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) }
+func (f *fmt) fmt_G32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) }
 
 // fmt_fb32 formats a float32 in the form -123p3 (exponent is power of 2).
-func (f *fmt) fmt_fb32(v float32)	{ f.padString(strconv.Ftoa32(v, 'b', 0)) }
+func (f *fmt) fmt_fb32(v float32) { f.padString(strconv.Ftoa32(v, 'b', 0)) }
 
 // float
 func (x *fmt) f(a float) {