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

2 files changed, 165 insertions, 165 deletions

diff --git a/src/pkg/encoding/ascii85/ascii85.go b/src/pkg/encoding/ascii85/ascii85.go
index ac446baf8..67d6ef7ed 100644
--- a/src/pkg/encoding/ascii85/ascii85.go
+++ b/src/pkg/encoding/ascii85/ascii85.go
@@ -7,9 +7,9 @@
 package ascii85
 
 import (
-	"io";
-	"os";
-	"strconv";
+	"io"
+	"os"
+	"strconv"
 )
 
 /*
@@ -30,74 +30,74 @@ func Encode(dst, src []byte) int {
 		return 0
 	}
 
-	n := 0;
+	n := 0
 	for len(src) > 0 {
-		dst[0] = 0;
-		dst[1] = 0;
-		dst[2] = 0;
-		dst[3] = 0;
-		dst[4] = 0;
+		dst[0] = 0
+		dst[1] = 0
+		dst[2] = 0
+		dst[3] = 0
+		dst[4] = 0
 
 		// Unpack 4 bytes into uint32 to repack into base 85 5-byte.
-		var v uint32;
+		var v uint32
 		switch len(src) {
 		default:
-			v |= uint32(src[3]);
-			fallthrough;
+			v |= uint32(src[3])
+			fallthrough
 		case 3:
-			v |= uint32(src[2]) << 8;
-			fallthrough;
+			v |= uint32(src[2]) << 8
+			fallthrough
 		case 2:
-			v |= uint32(src[1]) << 16;
-			fallthrough;
+			v |= uint32(src[1]) << 16
+			fallthrough
 		case 1:
 			v |= uint32(src[0]) << 24
 		}
 
 		// Special case: zero (!!!!!) shortens to z.
 		if v == 0 && len(src) >= 4 {
-			dst[0] = 'z';
-			dst = dst[1:];
-			n++;
-			continue;
+			dst[0] = 'z'
+			dst = dst[1:]
+			n++
+			continue
 		}
 
 		// Otherwise, 5 base 85 digits starting at !.
 		for i := 4; i >= 0; i-- {
-			dst[i] = '!' + byte(v%85);
-			v /= 85;
+			dst[i] = '!' + byte(v%85)
+			v /= 85
 		}
 
 		// If src was short, discard the low destination bytes.
-		m := 5;
+		m := 5
 		if len(src) < 4 {
-			m -= 4 - len(src);
-			src = nil;
+			m -= 4 - len(src)
+			src = nil
 		} else {
 			src = src[4:]
 		}
-		dst = dst[m:];
-		n += m;
+		dst = dst[m:]
+		n += m
 	}
-	return n;
+	return n
 }
 
 // MaxEncodedLen returns the maximum length of an encoding of n source bytes.
-func MaxEncodedLen(n int) int	{ return (n + 3) / 4 * 5 }
+func MaxEncodedLen(n int) int { return (n + 3) / 4 * 5 }
 
 // NewEncoder returns a new ascii85 stream encoder.  Data written to
 // the returned writer will be encoded and then written to w.
 // Ascii85 encodings operate in 32-bit blocks; when finished
 // writing, the caller must Close the returned encoder to flush any
 // trailing partial block.
-func NewEncoder(w io.Writer) io.WriteCloser	{ return &encoder{w: w} }
+func NewEncoder(w io.Writer) io.WriteCloser { return &encoder{w: w} }
 
 type encoder struct {
-	err	os.Error;
-	w	io.Writer;
-	buf	[4]byte;	// buffered data waiting to be encoded
-	nbuf	int;		// number of bytes in buf
-	out	[1024]byte;	// output buffer
+	err  os.Error
+	w    io.Writer
+	buf  [4]byte    // buffered data waiting to be encoded
+	nbuf int        // number of bytes in buf
+	out  [1024]byte // output buffer
 }
 
 func (e *encoder) Write(p []byte) (n int, err os.Error) {
@@ -107,47 +107,47 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 
 	// Leading fringe.
 	if e.nbuf > 0 {
-		var i int;
+		var i int
 		for i = 0; i < len(p) && e.nbuf < 4; i++ {
-			e.buf[e.nbuf] = p[i];
-			e.nbuf++;
+			e.buf[e.nbuf] = p[i]
+			e.nbuf++
 		}
-		n += i;
-		p = p[i:];
+		n += i
+		p = p[i:]
 		if e.nbuf < 4 {
 			return
 		}
-		nout := Encode(&e.out, &e.buf);
+		nout := Encode(&e.out, &e.buf)
 		if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
 			return n, e.err
 		}
-		e.nbuf = 0;
+		e.nbuf = 0
 	}
 
 	// Large interior chunks.
 	for len(p) >= 4 {
-		nn := len(e.out) / 5 * 4;
+		nn := len(e.out) / 5 * 4
 		if nn > len(p) {
 			nn = len(p)
 		}
-		nn -= nn % 4;
+		nn -= nn % 4
 		if nn > 0 {
-			nout := Encode(&e.out, p[0:nn]);
+			nout := Encode(&e.out, p[0:nn])
 			if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
 				return n, e.err
 			}
 		}
-		n += nn;
-		p = p[nn:];
+		n += nn
+		p = p[nn:]
 	}
 
 	// Trailing fringe.
 	for i := 0; i < len(p); i++ {
 		e.buf[i] = p[i]
 	}
-	e.nbuf = len(p);
-	n += len(p);
-	return;
+	e.nbuf = len(p)
+	n += len(p)
+	return
 }
 
 // Close flushes any pending output from the encoder.
@@ -155,11 +155,11 @@ func (e *encoder) Write(p []byte) (n int, err os.Error) {
 func (e *encoder) Close() os.Error {
 	// If there's anything left in the buffer, flush it out
 	if e.err == nil && e.nbuf > 0 {
-		nout := Encode(&e.out, e.buf[0:e.nbuf]);
-		e.nbuf = 0;
-		_, e.err = e.w.Write(e.out[0:nout]);
+		nout := Encode(&e.out, e.buf[0:e.nbuf])
+		e.nbuf = 0
+		_, e.err = e.w.Write(e.out[0:nout])
 	}
-	return e.err;
+	return e.err
 }
 
 /*
@@ -187,8 +187,8 @@ func (e CorruptInputError) String() string {
 // NewDecoder wraps an io.Reader interface around Decode.
 //
 func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
-	var v uint32;
-	var nb int;
+	var v uint32
+	var nb int
 	for i, b := range src {
 		if len(dst)-ndst < 4 {
 			return
@@ -197,27 +197,27 @@ func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
 		case b <= ' ':
 			continue
 		case b == 'z' && nb == 0:
-			nb = 5;
-			v = 0;
+			nb = 5
+			v = 0
 		case '!' <= b && b <= 'u':
-			v = v*85 + uint32(b-'!');
-			nb++;
+			v = v*85 + uint32(b-'!')
+			nb++
 		default:
 			return 0, 0, CorruptInputError(i)
 		}
 		if nb == 5 {
-			nsrc = i + 1;
-			dst[ndst] = byte(v >> 24);
-			dst[ndst+1] = byte(v >> 16);
-			dst[ndst+2] = byte(v >> 8);
-			dst[ndst+3] = byte(v);
-			ndst += 4;
-			nb = 0;
-			v = 0;
+			nsrc = i + 1
+			dst[ndst] = byte(v >> 24)
+			dst[ndst+1] = byte(v >> 16)
+			dst[ndst+2] = byte(v >> 8)
+			dst[ndst+3] = byte(v)
+			ndst += 4
+			nb = 0
+			v = 0
 		}
 	}
 	if flush {
-		nsrc = len(src);
+		nsrc = len(src)
 		if nb > 0 {
 			// The number of output bytes in the last fragment
 			// is the number of leftover input bytes - 1:
@@ -233,27 +233,27 @@ func Decode(dst, src []byte, flush bool) (ndst, nsrc int, err os.Error) {
 				v = v*85 + 84
 			}
 			for i := 0; i < nb-1; i++ {
-				dst[ndst] = byte(v >> 24);
-				v <<= 8;
-				ndst++;
+				dst[ndst] = byte(v >> 24)
+				v <<= 8
+				ndst++
 			}
 		}
 	}
-	return;
+	return
 }
 
 // NewDecoder constructs a new ascii85 stream decoder.
-func NewDecoder(r io.Reader) io.Reader	{ return &decoder{r: r} }
+func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }
 
 type decoder struct {
-	err	os.Error;
-	readErr	os.Error;
-	r	io.Reader;
-	end	bool;		// saw end of message
-	buf	[1024]byte;	// leftover input
-	nbuf	int;
-	out	[]byte;	// leftover decoded output
-	outbuf	[1024]byte;
+	err     os.Error
+	readErr os.Error
+	r       io.Reader
+	end     bool       // saw end of message
+	buf     [1024]byte // leftover input
+	nbuf    int
+	out     []byte // leftover decoded output
+	outbuf  [1024]byte
 }
 
 func (d *decoder) Read(p []byte) (n int, err os.Error) {
@@ -267,19 +267,19 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 	for {
 		// Copy leftover output from last decode.
 		if len(d.out) > 0 {
-			n = copy(p, d.out);
-			d.out = d.out[n:];
-			return;
+			n = copy(p, d.out)
+			d.out = d.out[n:]
+			return
 		}
 
 		// Decode leftover input from last read.
-		var nn, nsrc, ndst int;
+		var nn, nsrc, ndst int
 		if d.nbuf > 0 {
-			ndst, nsrc, d.err = Decode(&d.outbuf, d.buf[0:d.nbuf], d.readErr != nil);
+			ndst, nsrc, d.err = Decode(&d.outbuf, d.buf[0:d.nbuf], d.readErr != nil)
 			if ndst > 0 {
-				d.out = d.outbuf[0:ndst];
-				d.nbuf = copy(&d.buf, d.buf[nsrc:d.nbuf]);
-				continue;	// copy out and return
+				d.out = d.outbuf[0:ndst]
+				d.nbuf = copy(&d.buf, d.buf[nsrc:d.nbuf])
+				continue // copy out and return
 			}
 		}
 
@@ -288,13 +288,13 @@ func (d *decoder) Read(p []byte) (n int, err os.Error) {
 			return 0, d.err
 		}
 		if d.readErr != nil {
-			d.err = d.readErr;
-			return 0, d.err;
+			d.err = d.readErr
+			return 0, d.err
 		}
 
 		// Read more data.
-		nn, d.readErr = d.r.Read(d.buf[d.nbuf:]);
-		d.nbuf += nn;
+		nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
+		d.nbuf += nn
 	}
-	panic("unreachable");
+	panic("unreachable")
 }
diff --git a/src/pkg/encoding/ascii85/ascii85_test.go b/src/pkg/encoding/ascii85/ascii85_test.go
index 5ac49c675..7eb245ee2 100644
--- a/src/pkg/encoding/ascii85/ascii85_test.go
+++ b/src/pkg/encoding/ascii85/ascii85_test.go
@@ -5,16 +5,16 @@
 package ascii85
 
 import (
-	"bytes";
-	"io/ioutil";
-	"os";
-	"reflect";
-	"strings";
-	"testing";
+	"bytes"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
 )
 
 type testpair struct {
-	decoded, encoded string;
+	decoded, encoded string
 }
 
 var pairs = []testpair{
@@ -35,88 +35,88 @@ var pairs = []testpair{
 var bigtest = pairs[len(pairs)-1]
 
 func testEqual(t *testing.T, msg string, args ...) bool {
-	v := reflect.NewValue(args).(*reflect.StructValue);
-	v1 := v.Field(v.NumField() - 2);
-	v2 := v.Field(v.NumField() - 1);
+	v := reflect.NewValue(args).(*reflect.StructValue)
+	v1 := v.Field(v.NumField() - 2)
+	v2 := v.Field(v.NumField() - 1)
 	if v1.Interface() != v2.Interface() {
-		t.Errorf(msg, args);
-		return false;
+		t.Errorf(msg, args)
+		return false
 	}
-	return true;
+	return true
 }
 
 func strip85(s string) string {
-	t := make([]byte, len(s));
-	w := 0;
+	t := make([]byte, len(s))
+	w := 0
 	for r := 0; r < len(s); r++ {
-		c := s[r];
+		c := s[r]
 		if c > ' ' {
-			t[w] = c;
-			w++;
+			t[w] = c
+			w++
 		}
 	}
-	return string(t[0:w]);
+	return string(t[0:w])
 }
 
 func TestEncode(t *testing.T) {
 	for _, p := range pairs {
-		buf := make([]byte, MaxEncodedLen(len(p.decoded)));
-		n := Encode(buf, strings.Bytes(p.decoded));
-		buf = buf[0:n];
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded));
+		buf := make([]byte, MaxEncodedLen(len(p.decoded)))
+		n := Encode(buf, strings.Bytes(p.decoded))
+		buf = buf[0:n]
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded))
 	}
 }
 
 func TestEncoder(t *testing.T) {
 	for _, p := range pairs {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(bb);
-		encoder.Write(strings.Bytes(p.decoded));
-		encoder.Close();
-		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded));
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(bb)
+		encoder.Write(strings.Bytes(p.decoded))
+		encoder.Close()
+		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded))
 	}
 }
 
 func TestEncoderBuffering(t *testing.T) {
-	input := strings.Bytes(bigtest.decoded);
+	input := strings.Bytes(bigtest.decoded)
 	for bs := 1; bs <= 12; bs++ {
-		bb := &bytes.Buffer{};
-		encoder := NewEncoder(bb);
+		bb := &bytes.Buffer{}
+		encoder := NewEncoder(bb)
 		for pos := 0; pos < len(input); pos += bs {
-			end := pos + bs;
+			end := pos + bs
 			if end > len(input) {
 				end = len(input)
 			}
-			n, err := encoder.Write(input[pos:end]);
-			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil));
-			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos);
+			n, err := encoder.Write(input[pos:end])
+			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
+			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
 		}
-		err := encoder.Close();
-		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil));
-		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded));
+		err := encoder.Close()
+		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
+		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded))
 	}
 }
 
 func TestDecode(t *testing.T) {
 	for _, p := range pairs {
-		dbuf := make([]byte, 4*len(p.encoded));
-		ndst, nsrc, err := Decode(dbuf, strings.Bytes(p.encoded), true);
-		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil));
-		testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded));
-		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded));
-		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded);
+		dbuf := make([]byte, 4*len(p.encoded))
+		ndst, nsrc, err := Decode(dbuf, strings.Bytes(p.encoded), true)
+		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
+		testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded))
+		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
+		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
 	}
 }
 
 func TestDecoder(t *testing.T) {
 	for _, p := range pairs {
-		decoder := NewDecoder(bytes.NewBufferString(p.encoded));
-		dbuf, err := ioutil.ReadAll(decoder);
+		decoder := NewDecoder(bytes.NewBufferString(p.encoded))
+		dbuf, err := ioutil.ReadAll(decoder)
 		if err != nil {
 			t.Fatal("Read failed", err)
 		}
-		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded));
-		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded);
+		testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
+		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
 		if err != nil {
 			testEqual(t, "Read from %q = %v, want %v", p.encoded, err, os.EOF)
 		}
@@ -125,31 +125,31 @@ func TestDecoder(t *testing.T) {
 
 func TestDecoderBuffering(t *testing.T) {
 	for bs := 1; bs <= 12; bs++ {
-		decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded));
-		buf := make([]byte, len(bigtest.decoded)+12);
-		var total int;
+		decoder := NewDecoder(bytes.NewBufferString(bigtest.encoded))
+		buf := make([]byte, len(bigtest.decoded)+12)
+		var total int
 		for total = 0; total < len(bigtest.decoded); {
-			n, err := decoder.Read(buf[total : total+bs]);
-			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil));
-			total += n;
+			n, err := decoder.Read(buf[total : total+bs])
+			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
+			total += n
 		}
-		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded);
+		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
 	}
 }
 
 func TestDecodeCorrupt(t *testing.T) {
 	type corrupt struct {
-		e	string;
-		p	int;
+		e string
+		p int
 	}
 	examples := []corrupt{
 		corrupt{"v", 0},
 		corrupt{"!z!!!!!!!!!", 1},
-	};
+	}
 
 	for _, e := range examples {
-		dbuf := make([]byte, 4*len(e.e));
-		_, _, err := Decode(dbuf, strings.Bytes(e.e), true);
+		dbuf := make([]byte, 4*len(e.e))
+		_, _, err := Decode(dbuf, strings.Bytes(e.e), true)
 		switch err := err.(type) {
 		case CorruptInputError:
 			testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
@@ -160,34 +160,34 @@ func TestDecodeCorrupt(t *testing.T) {
 }
 
 func TestBig(t *testing.T) {
-	n := 3*1000 + 1;
-	raw := make([]byte, n);
-	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	n := 3*1000 + 1
+	raw := make([]byte, n)
+	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	for i := 0; i < n; i++ {
 		raw[i] = alpha[i%len(alpha)]
 	}
-	encoded := new(bytes.Buffer);
-	w := NewEncoder(encoded);
-	nn, err := w.Write(raw);
+	encoded := new(bytes.Buffer)
+	w := NewEncoder(encoded)
+	nn, err := w.Write(raw)
 	if nn != n || err != nil {
 		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
 	}
-	err = w.Close();
+	err = w.Close()
 	if err != nil {
 		t.Fatalf("Encoder.Close() = %v want nil", err)
 	}
-	decoded, err := ioutil.ReadAll(NewDecoder(encoded));
+	decoded, err := ioutil.ReadAll(NewDecoder(encoded))
 	if err != nil {
 		t.Fatalf("io.ReadAll(NewDecoder(...)): %v", err)
 	}
 
 	if !bytes.Equal(raw, decoded) {
-		var i int;
+		var i int
 		for i = 0; i < len(decoded) && i < len(raw); i++ {
 			if decoded[i] != raw[i] {
 				break
 			}
 		}
-		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i);
+		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
 	}
 }