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, 105 insertions, 105 deletions

diff --git a/src/pkg/exp/ogle/cmd.go b/src/pkg/exp/ogle/cmd.go
index 2e75fe519..45b47ef5b 100644
--- a/src/pkg/exp/ogle/cmd.go
+++ b/src/pkg/exp/ogle/cmd.go
@@ -6,52 +6,52 @@
 package ogle
 
 import (
-	"bufio";
-	"debug/elf";
-	"debug/proc";
-	"exp/eval";
-	"fmt";
-	"go/scanner";
-	"go/token";
-	"os";
-	"strconv";
-	"strings";
+	"bufio"
+	"debug/elf"
+	"debug/proc"
+	"exp/eval"
+	"fmt"
+	"go/scanner"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
 )
 
 var world *eval.World
 var curProc *Process
 
 func Main() {
-	world = eval.NewWorld();
-	defineFuncs();
-	r := bufio.NewReader(os.Stdin);
+	world = eval.NewWorld()
+	defineFuncs()
+	r := bufio.NewReader(os.Stdin)
 	for {
-		print("; ");
-		line, err := r.ReadSlice('\n');
+		print("; ")
+		line, err := r.ReadSlice('\n')
 		if err != nil {
 			break
 		}
 
 		// Try line as a command
-		cmd, rest := getCmd(line);
+		cmd, rest := getCmd(line)
 		if cmd != nil {
-			err := cmd.handler(rest);
+			err := cmd.handler(rest)
 			if err != nil {
 				scanner.PrintError(os.Stderr, err)
 			}
-			continue;
+			continue
 		}
 
 		// Try line as code
-		code, err := world.Compile(string(line));
+		code, err := world.Compile(string(line))
 		if err != nil {
-			scanner.PrintError(os.Stderr, err);
-			continue;
+			scanner.PrintError(os.Stderr, err)
+			continue
 		}
-		v, err := code.Run();
+		v, err := code.Run()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, err.String());
-			continue;
+			fmt.Fprintf(os.Stderr, err.String())
+			continue
 		}
 		if v != nil {
 			println(v.String())
@@ -61,11 +61,11 @@ func Main() {
 
 // newScanner creates a new scanner that scans that given input bytes.
 func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) {
-	sc := new(scanner.Scanner);
-	ev := new(scanner.ErrorVector);
-	sc.Init("input", input, ev, 0);
+	sc := new(scanner.Scanner)
+	ev := new(scanner.ErrorVector)
+	sc.Init("input", input, ev, 0)
 
-	return sc, ev;
+	return sc, ev
 }
 
 /*
@@ -75,12 +75,12 @@ func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) {
 // A UsageError occurs when a command is called with illegal arguments.
 type UsageError string
 
-func (e UsageError) String() string	{ return string(e) }
+func (e UsageError) String() string { return string(e) }
 
 // A cmd represents a single command with a handler.
 type cmd struct {
-	cmd	string;
-	handler	func([]byte) os.Error;
+	cmd     string
+	handler func([]byte) os.Error
 }
 
 var cmds = []cmd{
@@ -92,19 +92,19 @@ var cmds = []cmd{
 // successful, it returns the command and the bytes remaining after
 // the command, which should be passed to the command.
 func getCmd(line []byte) (*cmd, []byte) {
-	sc, _ := newScanner(line);
-	pos, tok, lit := sc.Scan();
+	sc, _ := newScanner(line)
+	pos, tok, lit := sc.Scan()
 	if sc.ErrorCount != 0 || tok != token.IDENT {
 		return nil, nil
 	}
 
-	slit := string(lit);
+	slit := string(lit)
 	for i := range cmds {
 		if cmds[i].cmd == slit {
 			return &cmds[i], line[pos.Offset+len(lit):]
 		}
 	}
-	return nil, nil;
+	return nil, nil
 }
 
 // cmdLoad starts or attaches to a process.  Its form is similar to
@@ -124,7 +124,7 @@ func getCmd(line []byte) (*cmd, []byte) {
 //
 // load always sets the current process to the loaded process.
 func cmdLoad(args []byte) os.Error {
-	ident, path, err := parseLoad(args);
+	ident, path, err := parseLoad(args)
 	if err != nil {
 		return err
 	}
@@ -136,99 +136,99 @@ func cmdLoad(args []byte) os.Error {
 	}
 
 	// Parse argument and start or attach to process
-	var fname string;
-	var tproc proc.Process;
+	var fname string
+	var tproc proc.Process
 	if len(path) >= 4 && path[0:4] == "pid:" {
-		pid, err := strconv.Atoi(path[4:]);
+		pid, err := strconv.Atoi(path[4:])
 		if err != nil {
 			return err
 		}
-		fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid));
+		fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid))
 		if err != nil {
 			return err
 		}
-		tproc, err = proc.Attach(pid);
+		tproc, err = proc.Attach(pid)
 		if err != nil {
 			return err
 		}
-		println("Attached to", pid);
+		println("Attached to", pid)
 	} else {
-		parts := strings.Split(path, " ", 0);
+		parts := strings.Split(path, " ", 0)
 		if len(parts) == 0 {
 			fname = ""
 		} else {
 			fname = parts[0]
 		}
-		tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr});
+		tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr})
 		if err != nil {
 			return err
 		}
-		println("Started", path);
+		println("Started", path)
 		// TODO(austin) If we fail after this point, kill tproc
 		// before detaching.
 	}
 
 	// Get symbols
-	f, err := os.Open(fname, os.O_RDONLY, 0);
+	f, err := os.Open(fname, os.O_RDONLY, 0)
 	if err != nil {
-		tproc.Detach();
-		return err;
+		tproc.Detach()
+		return err
 	}
-	defer f.Close();
-	elf, err := elf.NewFile(f);
+	defer f.Close()
+	elf, err := elf.NewFile(f)
 	if err != nil {
-		tproc.Detach();
-		return err;
+		tproc.Detach()
+		return err
 	}
-	curProc, err = NewProcessElf(tproc, elf);
+	curProc, err = NewProcessElf(tproc, elf)
 	if err != nil {
-		tproc.Detach();
-		return err;
+		tproc.Detach()
+		return err
 	}
 
 	// Prepare new process
-	curProc.OnGoroutineCreate().AddHandler(EventPrint);
-	curProc.OnGoroutineExit().AddHandler(EventPrint);
+	curProc.OnGoroutineCreate().AddHandler(EventPrint)
+	curProc.OnGoroutineExit().AddHandler(EventPrint)
 
-	err = curProc.populateWorld(world);
+	err = curProc.populateWorld(world)
 	if err != nil {
-		tproc.Detach();
-		return err;
+		tproc.Detach()
+		return err
 	}
 
-	return nil;
+	return nil
 }
 
 func parseLoad(args []byte) (ident string, path string, err os.Error) {
-	err = UsageError("Usage: load [sym] \"path\"");
-	sc, ev := newScanner(args);
+	err = UsageError("Usage: load [sym] \"path\"")
+	sc, ev := newScanner(args)
 
-	var toks [4]token.Token;
-	var lits [4][]byte;
+	var toks [4]token.Token
+	var lits [4][]byte
 	for i := range toks {
 		_, toks[i], lits[i] = sc.Scan()
 	}
 	if sc.ErrorCount != 0 {
-		err = ev.GetError(scanner.NoMultiples);
-		return;
+		err = ev.GetError(scanner.NoMultiples)
+		return
 	}
 
-	i := 0;
+	i := 0
 	switch toks[i] {
 	case token.PERIOD, token.IDENT:
-		ident = string(lits[i]);
-		i++;
+		ident = string(lits[i])
+		i++
 	}
 
 	if toks[i] != token.STRING {
 		return
 	}
-	path, uerr := strconv.Unquote(string(lits[i]));
+	path, uerr := strconv.Unquote(string(lits[i]))
 	if uerr != nil {
-		err = uerr;
-		return;
+		err = uerr
+		return
 	}
-	i++;
+	i++
 
 	if toks[i] == token.SEMICOLON {
 		i++
@@ -237,13 +237,13 @@ func parseLoad(args []byte) (ident string, path string, err os.Error) {
 		return
 	}
 
-	return ident, path, nil;
+	return ident, path, nil
 }
 
 // cmdBt prints a backtrace for the current goroutine.  It takes no
 // arguments.
 func cmdBt(args []byte) os.Error {
-	err := parseNoArgs(args, "Usage: bt");
+	err := parseNoArgs(args, "Usage: bt")
 	if err != nil {
 		return err
 	}
@@ -252,10 +252,10 @@ func cmdBt(args []byte) os.Error {
 		return NoCurrentGoroutine{}
 	}
 
-	f := curProc.curGoroutine.frame;
+	f := curProc.curGoroutine.frame
 	if f == nil {
-		fmt.Println("No frames on stack");
-		return nil;
+		fmt.Println("No frames on stack")
+		return nil
 	}
 
 	for f.Inner() != nil {
@@ -268,8 +268,8 @@ func cmdBt(args []byte) os.Error {
 		} else {
 			fmt.Printf("   ")
 		}
-		fmt.Printf("%8x %v\n", f.pc, f);
-		f, err = f.Outer();
+		fmt.Printf("%8x %v\n", f.pc, f)
+		f, err = f.Outer()
 		if err != nil {
 			return err
 		}
@@ -278,20 +278,20 @@ func cmdBt(args []byte) os.Error {
 		}
 	}
 
-	fmt.Println("...");
-	return nil;
+	fmt.Println("...")
+	return nil
 }
 
 func parseNoArgs(args []byte, usage string) os.Error {
-	sc, ev := newScanner(args);
-	_, tok, _ := sc.Scan();
+	sc, ev := newScanner(args)
+	_, tok, _ := sc.Scan()
 	if sc.ErrorCount != 0 {
 		return ev.GetError(scanner.NoMultiples)
 	}
 	if tok != token.EOF {
 		return UsageError(usage)
 	}
-	return nil;
+	return nil
 }
 
 /*
@@ -300,12 +300,12 @@ func parseNoArgs(args []byte, usage string) os.Error {
 
 // defineFuncs populates world with the built-in functions.
 func defineFuncs() {
-	t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig);
-	world.DefineConst("Out", t, v);
-	t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig);
-	world.DefineConst("ContWait", t, v);
-	t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig);
-	world.DefineConst("BpSet", t, v);
+	t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig)
+	world.DefineConst("Out", t, v)
+	t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig)
+	world.DefineConst("ContWait", t, v)
+	t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig)
+	world.DefineConst("BpSet", t, v)
 }
 
 // printCurFrame prints the current stack frame, as it would appear in
@@ -314,47 +314,47 @@ func printCurFrame() {
 	if curProc == nil || curProc.curGoroutine == nil {
 		return
 	}
-	f := curProc.curGoroutine.frame;
+	f := curProc.curGoroutine.frame
 	if f == nil {
 		return
 	}
-	fmt.Printf("=> %8x %v\n", f.pc, f);
+	fmt.Printf("=> %8x %v\n", f.pc, f)
 }
 
 // fnOut moves the current frame to the caller of the current frame.
-func fnOutSig()	{}
+func fnOutSig() {}
 func fnOut(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	if curProc == nil {
 		t.Abort(NoCurrentGoroutine{})
 	}
-	err := curProc.Out();
+	err := curProc.Out()
 	if err != nil {
 		t.Abort(err)
 	}
 	// TODO(austin) Only in the command form
-	printCurFrame();
+	printCurFrame()
 }
 
 // fnContWait continues the current process and waits for a stopping event.
-func fnContWaitSig()	{}
+func fnContWaitSig() {}
 func fnContWait(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	if curProc == nil {
 		t.Abort(NoCurrentGoroutine{})
 	}
-	err := curProc.ContWait();
+	err := curProc.ContWait()
 	if err != nil {
 		t.Abort(err)
 	}
 	// TODO(austin) Only in the command form
-	ev := curProc.Event();
+	ev := curProc.Event()
 	if ev != nil {
 		fmt.Printf("%v\n", ev)
 	}
-	printCurFrame();
+	printCurFrame()
 }
 
 // fnBpSet sets a breakpoint at the entry to the named function.
-func fnBpSetSig(string)	{}
+func fnBpSetSig(string) {}
 func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	// TODO(austin) This probably shouldn't take a symbol name.
 	// Perhaps it should take an interface that provides PC's.
@@ -363,10 +363,10 @@ func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	if curProc == nil {
 		t.Abort(NoCurrentGoroutine{})
 	}
-	name := args[0].(eval.StringValue).Get(t);
-	fn := curProc.syms.LookupFunc(name);
+	name := args[0].(eval.StringValue).Get(t)
+	fn := curProc.syms.LookupFunc(name)
 	if fn == nil {
 		t.Abort(UsageError("no such function " + name))
 	}
-	curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop);
+	curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop)
 }