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

5th and last set of files.

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

1 files changed, 47 insertions, 47 deletions

diff --git a/src/pkg/testing/testing.go b/src/pkg/testing/testing.go
index 654d344c0..77f9942d8 100644
--- a/src/pkg/testing/testing.go
+++ b/src/pkg/testing/testing.go
@@ -39,10 +39,10 @@
 package testing
 
 import (
-	"flag";
-	"fmt";
-	"os";
-	"runtime";
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
 )
 
 // Report as tests are run; default is silent for success.
@@ -52,44 +52,44 @@ var match = flag.String("match", "", "regular expression to select tests to run"
 
 // Insert final newline if needed and tabs after internal newlines.
 func tabify(s string) string {
-	n := len(s);
+	n := len(s)
 	if n > 0 && s[n-1] != '\n' {
-		s += "\n";
-		n++;
+		s += "\n"
+		n++
 	}
-	for i := 0; i < n-1; i++ {	// -1 to avoid final newline
+	for i := 0; i < n-1; i++ { // -1 to avoid final newline
 		if s[i] == '\n' {
 			return s[0:i+1] + "\t" + tabify(s[i+1:n])
 		}
 	}
-	return s;
+	return s
 }
 
 // T is a type passed to Test functions to manage test state and support formatted test logs.
 // Logs are accumulated during execution and dumped to standard error when done.
 type T struct {
-	errors	string;
-	failed	bool;
-	ch	chan *T;
+	errors string
+	failed bool
+	ch     chan *T
 }
 
 // Fail marks the Test function as having failed but continues execution.
-func (t *T) Fail()	{ t.failed = true }
+func (t *T) Fail() { t.failed = true }
 
 // Failed returns whether the Test function has failed.
-func (t *T) Failed() bool	{ return t.failed }
+func (t *T) Failed() bool { return t.failed }
 
 // FailNow marks the Test function as having failed and stops its execution.
 // Execution will continue at the next Test.
 func (t *T) FailNow() {
-	t.Fail();
-	t.ch <- t;
-	runtime.Goexit();
+	t.Fail()
+	t.ch <- t
+	runtime.Goexit()
 }
 
 // Log formats its arguments using default formatting, analogous to Print(),
 // and records the text in the error log.
-func (t *T) Log(args ...)	{ t.errors += "\t" + tabify(fmt.Sprintln(args)) }
+func (t *T) Log(args ...) { t.errors += "\t" + tabify(fmt.Sprintln(args)) }
 
 // Log formats its arguments according to the format, analogous to Printf(),
 // and records the text in the error log.
@@ -99,52 +99,52 @@ func (t *T) Logf(format string, args ...) {
 
 // Error is equivalent to Log() followed by Fail().
 func (t *T) Error(args ...) {
-	t.Log(args);
-	t.Fail();
+	t.Log(args)
+	t.Fail()
 }
 
 // Errorf is equivalent to Logf() followed by Fail().
 func (t *T) Errorf(format string, args ...) {
-	t.Logf(format, args);
-	t.Fail();
+	t.Logf(format, args)
+	t.Fail()
 }
 
 // Fatal is equivalent to Log() followed by FailNow().
 func (t *T) Fatal(args ...) {
-	t.Log(args);
-	t.FailNow();
+	t.Log(args)
+	t.FailNow()
 }
 
 // Fatalf is equivalent to Logf() followed by FailNow().
 func (t *T) Fatalf(format string, args ...) {
-	t.Logf(format, args);
-	t.FailNow();
+	t.Logf(format, args)
+	t.FailNow()
 }
 
 // An internal type but exported because it is cross-package; part of the implementation
 // of gotest.
 type Test struct {
-	Name	string;
-	F	func(*T);
+	Name string
+	F    func(*T)
 }
 
 func tRunner(t *T, test *Test) {
-	test.F(t);
-	t.ch <- t;
+	test.F(t)
+	t.ch <- t
 }
 
 // An internal function but exported because it is cross-package; part of the implementation
 // of gotest.
 func Main(tests []Test) {
-	flag.Parse();
-	ok := true;
+	flag.Parse()
+	ok := true
 	if len(tests) == 0 {
 		println("testing: warning: no tests to run")
 	}
-	re, err := CompileRegexp(*match);
+	re, err := CompileRegexp(*match)
 	if err != "" {
-		println("invalid regexp for -match:", err);
-		os.Exit(1);
+		println("invalid regexp for -match:", err)
+		os.Exit(1)
 	}
 	for i := 0; i < len(tests); i++ {
 		if !re.MatchString(tests[i].Name) {
@@ -153,22 +153,22 @@ func Main(tests []Test) {
 		if *chatty {
 			println("=== RUN ", tests[i].Name)
 		}
-		t := new(T);
-		t.ch = make(chan *T);
-		go tRunner(t, &tests[i]);
-		<-t.ch;
+		t := new(T)
+		t.ch = make(chan *T)
+		go tRunner(t, &tests[i])
+		<-t.ch
 		if t.failed {
-			println("--- FAIL:", tests[i].Name);
-			print(t.errors);
-			ok = false;
+			println("--- FAIL:", tests[i].Name)
+			print(t.errors)
+			ok = false
 		} else if *chatty {
-			println("--- PASS:", tests[i].Name);
-			print(t.errors);
+			println("--- PASS:", tests[i].Name)
+			print(t.errors)
 		}
 	}
 	if !ok {
-		println("FAIL");
-		os.Exit(1);
+		println("FAIL")
+		os.Exit(1)
 	}
-	println("PASS");
+	println("PASS")
 }