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

3rd set of files.

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

1 files changed, 69 insertions, 69 deletions

diff --git a/src/pkg/net/server_test.go b/src/pkg/net/server_test.go
index 404108106..3b8f1c935 100644
--- a/src/pkg/net/server_test.go
+++ b/src/pkg/net/server_test.go
@@ -5,12 +5,12 @@
 package net
 
 import (
-	"flag";
-	"io";
-	"os";
-	"strings";
-	"syscall";
-	"testing";
+	"flag"
+	"io"
+	"os"
+	"strings"
+	"syscall"
+	"testing"
 )
 
 // Do not test empty datagrams by default.
@@ -20,97 +20,97 @@ import (
 var testEmptyDatagrams = flag.Bool("empty_datagrams", false, "whether to test empty datagrams")
 
 func runEcho(fd io.ReadWriter, done chan<- int) {
-	var buf [1024]byte;
+	var buf [1024]byte
 
 	for {
-		n, err := fd.Read(&buf);
+		n, err := fd.Read(&buf)
 		if err != nil || n == 0 {
 			break
 		}
-		fd.Write(buf[0:n]);
+		fd.Write(buf[0:n])
 	}
-	done <- 1;
+	done <- 1
 }
 
 func runServe(t *testing.T, network, addr string, listening chan<- string, done chan<- int) {
-	l, err := Listen(network, addr);
+	l, err := Listen(network, addr)
 	if err != nil {
 		t.Fatalf("net.Listen(%q, %q) = _, %v", network, addr, err)
 	}
-	listening <- l.Addr().String();
+	listening <- l.Addr().String()
 
 	for {
-		fd, err := l.Accept();
+		fd, err := l.Accept()
 		if err != nil {
 			break
 		}
-		echodone := make(chan int);
-		go runEcho(fd, echodone);
-		<-echodone;	// make sure Echo stops
-		l.Close();
+		echodone := make(chan int)
+		go runEcho(fd, echodone)
+		<-echodone // make sure Echo stops
+		l.Close()
 	}
-	done <- 1;
+	done <- 1
 }
 
 func connect(t *testing.T, network, addr string, isEmpty bool) {
-	var laddr string;
+	var laddr string
 	if network == "unixgram" {
 		laddr = addr + ".local"
 	}
-	fd, err := Dial(network, laddr, addr);
+	fd, err := Dial(network, laddr, addr)
 	if err != nil {
 		t.Fatalf("net.Dial(%q, %q, %q) = _, %v", network, laddr, addr, err)
 	}
-	fd.SetReadTimeout(1e9);	// 1s
+	fd.SetReadTimeout(1e9) // 1s
 
-	var b []byte;
+	var b []byte
 	if !isEmpty {
 		b = strings.Bytes("hello, world\n")
 	}
-	var b1 [100]byte;
+	var b1 [100]byte
 
-	n, err := fd.Write(b);
+	n, err := fd.Write(b)
 	if n != len(b) {
 		t.Fatalf("fd.Write(%q) = %d, %v", b, n, err)
 	}
 
-	n, err = fd.Read(&b1);
+	n, err = fd.Read(&b1)
 	if n != len(b) || err != nil {
 		t.Fatalf("fd.Read() = %d, %v (want %d, nil)", n, err, len(b))
 	}
-	fd.Close();
+	fd.Close()
 }
 
 func doTest(t *testing.T, network, listenaddr, dialaddr string) {
-	t.Logf("Test %s %s %s\n", network, listenaddr, dialaddr);
-	listening := make(chan string);
-	done := make(chan int);
+	t.Logf("Test %s %s %s\n", network, listenaddr, dialaddr)
+	listening := make(chan string)
+	done := make(chan int)
 	if network == "tcp" {
-		listenaddr += ":0"	// any available port
+		listenaddr += ":0" // any available port
 	}
-	go runServe(t, network, listenaddr, listening, done);
-	addr := <-listening;	// wait for server to start
+	go runServe(t, network, listenaddr, listening, done)
+	addr := <-listening // wait for server to start
 	if network == "tcp" {
 		dialaddr += addr[strings.LastIndex(addr, ":"):]
 	}
-	connect(t, network, dialaddr, false);
-	<-done;	// make sure server stopped
+	connect(t, network, dialaddr, false)
+	<-done // make sure server stopped
 }
 
 func TestTCPServer(t *testing.T) {
-	doTest(t, "tcp", "0.0.0.0", "127.0.0.1");
-	doTest(t, "tcp", "", "127.0.0.1");
+	doTest(t, "tcp", "0.0.0.0", "127.0.0.1")
+	doTest(t, "tcp", "", "127.0.0.1")
 	if kernelSupportsIPv6() {
-		doTest(t, "tcp", "[::]", "[::ffff:127.0.0.1]");
-		doTest(t, "tcp", "[::]", "127.0.0.1");
-		doTest(t, "tcp", "0.0.0.0", "[::ffff:127.0.0.1]");
+		doTest(t, "tcp", "[::]", "[::ffff:127.0.0.1]")
+		doTest(t, "tcp", "[::]", "127.0.0.1")
+		doTest(t, "tcp", "0.0.0.0", "[::ffff:127.0.0.1]")
 	}
 }
 
 func TestUnixServer(t *testing.T) {
-	os.Remove("/tmp/gotest.net");
-	doTest(t, "unix", "/tmp/gotest.net", "/tmp/gotest.net");
-	os.Remove("/tmp/gotest.net");
+	os.Remove("/tmp/gotest.net")
+	doTest(t, "unix", "/tmp/gotest.net", "/tmp/gotest.net")
+	os.Remove("/tmp/gotest.net")
 	if syscall.OS == "linux" {
 		// Test abstract unix domain socket, a Linux-ism
 		doTest(t, "unix", "@gotest/net", "@gotest/net")
@@ -118,20 +118,20 @@ func TestUnixServer(t *testing.T) {
 }
 
 func runPacket(t *testing.T, network, addr string, listening chan<- string, done chan<- int) {
-	c, err := ListenPacket(network, addr);
+	c, err := ListenPacket(network, addr)
 	if err != nil {
 		t.Fatalf("net.ListenPacket(%q, %q) = _, %v", network, addr, err)
 	}
-	listening <- c.LocalAddr().String();
-	c.SetReadTimeout(10e6);	// 10ms
-	var buf [1000]byte;
+	listening <- c.LocalAddr().String()
+	c.SetReadTimeout(10e6) // 10ms
+	var buf [1000]byte
 	for {
-		n, addr, err := c.ReadFrom(&buf);
+		n, addr, err := c.ReadFrom(&buf)
 		if isEAGAIN(err) {
 			if done <- 1 {
 				break
 			}
-			continue;
+			continue
 		}
 		if err != nil {
 			break
@@ -140,46 +140,46 @@ func runPacket(t *testing.T, network, addr string, listening chan<- string, done
 			t.Fatalf("WriteTo %v: %v", addr, err)
 		}
 	}
-	c.Close();
-	done <- 1;
+	c.Close()
+	done <- 1
 }
 
 func doTestPacket(t *testing.T, network, listenaddr, dialaddr string, isEmpty bool) {
-	t.Logf("TestPacket %s %s %s\n", network, listenaddr, dialaddr);
-	listening := make(chan string);
-	done := make(chan int);
+	t.Logf("TestPacket %s %s %s\n", network, listenaddr, dialaddr)
+	listening := make(chan string)
+	done := make(chan int)
 	if network == "udp" {
-		listenaddr += ":0"	// any available port
+		listenaddr += ":0" // any available port
 	}
-	go runPacket(t, network, listenaddr, listening, done);
-	addr := <-listening;	// wait for server to start
+	go runPacket(t, network, listenaddr, listening, done)
+	addr := <-listening // wait for server to start
 	if network == "udp" {
 		dialaddr += addr[strings.LastIndex(addr, ":"):]
 	}
-	connect(t, network, dialaddr, isEmpty);
-	<-done;	// tell server to stop
-	<-done;	// wait for stop
+	connect(t, network, dialaddr, isEmpty)
+	<-done // tell server to stop
+	<-done // wait for stop
 }
 
 func TestUDPServer(t *testing.T) {
 	for _, isEmpty := range []bool{false, *testEmptyDatagrams} {
-		doTestPacket(t, "udp", "0.0.0.0", "127.0.0.1", isEmpty);
-		doTestPacket(t, "udp", "", "127.0.0.1", isEmpty);
+		doTestPacket(t, "udp", "0.0.0.0", "127.0.0.1", isEmpty)
+		doTestPacket(t, "udp", "", "127.0.0.1", isEmpty)
 		if kernelSupportsIPv6() {
-			doTestPacket(t, "udp", "[::]", "[::ffff:127.0.0.1]", isEmpty);
-			doTestPacket(t, "udp", "[::]", "127.0.0.1", isEmpty);
-			doTestPacket(t, "udp", "0.0.0.0", "[::ffff:127.0.0.1]", isEmpty);
+			doTestPacket(t, "udp", "[::]", "[::ffff:127.0.0.1]", isEmpty)
+			doTestPacket(t, "udp", "[::]", "127.0.0.1", isEmpty)
+			doTestPacket(t, "udp", "0.0.0.0", "[::ffff:127.0.0.1]", isEmpty)
 		}
 	}
 }
 
 func TestUnixDatagramServer(t *testing.T) {
 	for _, isEmpty := range []bool{false, *testEmptyDatagrams} {
-		os.Remove("/tmp/gotest1.net");
-		os.Remove("/tmp/gotest1.net.local");
-		doTestPacket(t, "unixgram", "/tmp/gotest1.net", "/tmp/gotest1.net", isEmpty);
-		os.Remove("/tmp/gotest1.net");
-		os.Remove("/tmp/gotest1.net.local");
+		os.Remove("/tmp/gotest1.net")
+		os.Remove("/tmp/gotest1.net.local")
+		doTestPacket(t, "unixgram", "/tmp/gotest1.net", "/tmp/gotest1.net", isEmpty)
+		os.Remove("/tmp/gotest1.net")
+		os.Remove("/tmp/gotest1.net.local")
 		if syscall.OS == "linux" {
 			// Test abstract unix domain socket, a Linux-ism
 			doTestPacket(t, "unixgram", "@gotest1/net", "@gotest1/net", isEmpty)