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

diff --git a/src/pkg/debug/proc/proc.go b/src/pkg/debug/proc/proc.go
index 7f8e778c6..d5341a745 100644
--- a/src/pkg/debug/proc/proc.go
+++ b/src/pkg/debug/proc/proc.go
@@ -13,22 +13,22 @@ package proc
 // and proc_darwin.go do, because deps.bash only looks at
 // this file.
 import (
-	_ "container/vector";
-	_ "fmt";
-	_ "io";
-	"os";
-	_ "runtime";
-	"strconv";
-	_ "strings";
-	_ "sync";
-	_ "syscall";
+	_ "container/vector"
+	_ "fmt"
+	_ "io"
+	"os"
+	_ "runtime"
+	"strconv"
+	_ "strings"
+	_ "sync"
+	_ "syscall"
 )
 
 type Word uint64
 
 // A Cause explains why a thread is stopped.
 type Cause interface {
-	String() string;
+	String() string
 }
 
 // Regs is a set of named machine registers, including a program
@@ -42,33 +42,33 @@ type Cause interface {
 // other per-register information like how to print it.
 type Regs interface {
 	// PC returns the value of the program counter.
-	PC() Word;
+	PC() Word
 
 	// SetPC sets the program counter to val.
-	SetPC(val Word) os.Error;
+	SetPC(val Word) os.Error
 
 	// Link returns the link register, if any.
-	Link() Word;
+	Link() Word
 
 	// SetLink sets the link register to val.
-	SetLink(val Word) os.Error;
+	SetLink(val Word) os.Error
 
 	// SP returns the value of the stack pointer.
-	SP() Word;
+	SP() Word
 
 	// SetSP sets the stack pointer register to val.
-	SetSP(val Word) os.Error;
+	SetSP(val Word) os.Error
 
 	// Names returns the names of all of the registers.
-	Names() []string;
+	Names() []string
 
 	// Get returns the value of a register, where i corresponds to
 	// the index of the register's name in the array returned by
 	// Names.
-	Get(i int) Word;
+	Get(i int) Word
 
 	// Set sets the value of a register.
-	Set(i int, val Word) os.Error;
+	Set(i int, val Word) os.Error
 }
 
 // Thread is a thread in the process being traced.
@@ -78,15 +78,15 @@ type Thread interface {
 	// breakpoint, this will step over the breakpoint.
 	//
 	// XXX What if it's stopped because of a signal?
-	Step() os.Error;
+	Step() os.Error
 
 	// Stopped returns the reason that this thread is stopped.  It
 	// is an error is the thread not stopped.
-	Stopped() (Cause, os.Error);
+	Stopped() (Cause, os.Error)
 
 	// Regs retrieves the current register values from this
 	// thread.  The thread must be stopped.
-	Regs() (Regs, os.Error);
+	Regs() (Regs, os.Error)
 
 	// Peek reads len(out) bytes from the address addr in this
 	// thread into out.  The thread must be stopped.  It returns
@@ -95,7 +95,7 @@ type Thread interface {
 	// could be short and an error will be returned.  If this does
 	// encounter unmapped memory, it will read up to the byte
 	// preceding the unmapped area.
-	Peek(addr Word, out []byte) (int, os.Error);
+	Peek(addr Word, out []byte) (int, os.Error)
 
 	// Poke writes b to the address addr in this thread.  The
 	// thread must be stopped.  It returns the number of bytes
@@ -104,7 +104,7 @@ type Thread interface {
 	// short and an error will be returned.  If this does
 	// encounter unmapped memory, it will write up to the byte
 	// preceding the unmapped area.
-	Poke(addr Word, b []byte) (int, os.Error);
+	Poke(addr Word, b []byte) (int, os.Error)
 }
 
 // Process is a process being traced.  It consists of a set of
@@ -112,37 +112,37 @@ type Thread interface {
 // process's state extends to all of its threads.
 type Process interface {
 	// Threads returns an array of all threads in this process.
-	Threads() []Thread;
+	Threads() []Thread
 
 	// AddBreakpoint creates a new breakpoint at program counter
 	// pc.  Breakpoints can only be created when the process is
 	// stopped.  It is an error if a breakpoint already exists at
 	// pc.
-	AddBreakpoint(pc Word) os.Error;
+	AddBreakpoint(pc Word) os.Error
 
 	// RemoveBreakpoint removes the breakpoint at the program
 	// counter pc.  It is an error if no breakpoint exists at pc.
-	RemoveBreakpoint(pc Word) os.Error;
+	RemoveBreakpoint(pc Word) os.Error
 
 	// Stop stops all running threads in this process before
 	// returning.
-	Stop() os.Error;
+	Stop() os.Error
 
 	// Continue resumes execution of all threads in this process.
 	// Any thread that is stopped on a breakpoint will be stepped
 	// over that breakpoint.  Any thread that is stopped because
 	// of a signal (other than SIGSTOP or SIGTRAP) will receive
 	// the pending signal.
-	Continue() os.Error;
+	Continue() os.Error
 
 	// WaitStop waits until all threads in process p are stopped
 	// as a result of some thread hitting a breakpoint, receiving
 	// a signal, creating a new thread, or exiting.
-	WaitStop() os.Error;
+	WaitStop() os.Error
 
 	// Detach detaches from this process.  All stopped threads
 	// will be resumed.
-	Detach() os.Error;
+	Detach() os.Error
 }
 
 // Stopped is a stop cause used for threads that are stopped either by
@@ -151,14 +151,14 @@ type Process interface {
 // stop.
 type Stopped struct{}
 
-func (c Stopped) String() string	{ return "stopped" }
+func (c Stopped) String() string { return "stopped" }
 
 // Breakpoint is a stop cause resulting from a thread reaching a set
 // breakpoint.
 type Breakpoint Word
 
 // PC returns the program counter that the program is stopped at.
-func (c Breakpoint) PC() Word	{ return Word(c) }
+func (c Breakpoint) PC() Word { return Word(c) }
 
 func (c Breakpoint) String() string {
 	return "breakpoint at 0x" + strconv.Uitob64(uint64(c.PC()), 16)
@@ -169,47 +169,47 @@ func (c Breakpoint) String() string {
 type Signal string
 
 // Signal returns the signal being delivered to the thread.
-func (c Signal) Name() string	{ return string(c) }
+func (c Signal) Name() string { return string(c) }
 
-func (c Signal) String() string	{ return c.Name() }
+func (c Signal) String() string { return c.Name() }
 
 // ThreadCreate is a stop cause returned from an existing thread when
 // it creates a new thread.  The new thread exists in a primordial
 // form at this point and will begin executing in earnest when the
 // process is continued.
 type ThreadCreate struct {
-	thread Thread;
+	thread Thread
 }
 
-func (c *ThreadCreate) NewThread() Thread	{ return c.thread }
+func (c *ThreadCreate) NewThread() Thread { return c.thread }
 
-func (c *ThreadCreate) String() string	{ return "thread create" }
+func (c *ThreadCreate) String() string { return "thread create" }
 
 // ThreadExit is a stop cause resulting from a thread exiting.  When
 // this cause first arises, the thread will still be in the list of
 // process threads and its registers and memory will still be
 // accessible.
 type ThreadExit struct {
-	exitStatus	int;
-	signal		string;
+	exitStatus int
+	signal     string
 }
 
 // Exited returns true if the thread exited normally.
-func (c *ThreadExit) Exited() bool	{ return c.exitStatus != -1 }
+func (c *ThreadExit) Exited() bool { return c.exitStatus != -1 }
 
 // ExitStatus returns the exit status of the thread if it exited
 // normally or -1 otherwise.
-func (c *ThreadExit) ExitStatus() int	{ return c.exitStatus }
+func (c *ThreadExit) ExitStatus() int { return c.exitStatus }
 
 // Signaled returns true if the thread was terminated by a signal.
-func (c *ThreadExit) Signaled() bool	{ return c.exitStatus == -1 }
+func (c *ThreadExit) Signaled() bool { return c.exitStatus == -1 }
 
 // StopSignal returns the signal that terminated the thread, or "" if
 // it was not terminated by a signal.
-func (c *ThreadExit) StopSignal() string	{ return c.signal }
+func (c *ThreadExit) StopSignal() string { return c.signal }
 
 func (c *ThreadExit) String() string {
-	res := "thread exited ";
+	res := "thread exited "
 	switch {
 	case c.Exited():
 		res += "with status " + strconv.Itoa(c.ExitStatus())
@@ -218,5 +218,5 @@ func (c *ThreadExit) String() string {
 	default:
 		res += "from unknown cause"
 	}
-	return res;
+	return res
 }