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

diff --git a/src/pkg/exp/nacl/srpc/client.go b/src/pkg/exp/nacl/srpc/client.go
index d19b48888..9e47376f8 100644
--- a/src/pkg/exp/nacl/srpc/client.go
+++ b/src/pkg/exp/nacl/srpc/client.go
@@ -6,48 +6,48 @@
 package srpc
 
 import (
-	"bytes";
-	"log";
-	"os";
-	"sync";
+	"bytes"
+	"log"
+	"os"
+	"sync"
 )
 
 // A Client represents the client side of an SRPC connection.
 type Client struct {
-	fd	int;	// fd to server
-	r	msgReceiver;
-	s	msgSender;
-	service	map[string]srv;	// services by name
-	out	chan *msg;	// send to out to write to connection
-
-	mu	sync.Mutex;	// protects pending, idGen
-	pending	map[uint64]*RPC;
-	idGen	uint64;	// generator for request IDs
+	fd      int // fd to server
+	r       msgReceiver
+	s       msgSender
+	service map[string]srv // services by name
+	out     chan *msg      // send to out to write to connection
+
+	mu      sync.Mutex // protects pending, idGen
+	pending map[uint64]*RPC
+	idGen   uint64 // generator for request IDs
 }
 
 // A srv is a single method that the server offers.
 type srv struct {
-	num	uint32;	// method number
-	fmt	string;	// argument format
+	num uint32 // method number
+	fmt string // argument format
 }
 
 // An RPC represents a single RPC issued by a client.
 type RPC struct {
-	Ret	[]interface{};	// Return values
-	Done	chan *RPC;	// Channel where notification of done arrives
-	Errno	Errno;		// Status code
-	c	*Client;
-	id	uint64;	// request id
+	Ret   []interface{} // Return values
+	Done  chan *RPC     // Channel where notification of done arrives
+	Errno Errno         // Status code
+	c     *Client
+	id    uint64 // request id
 }
 
 // NewClient allocates a new client using the file descriptor fd.
 func NewClient(fd int) (c *Client, err os.Error) {
-	c = new(Client);
-	c.fd = fd;
-	c.r.fd = fd;
-	c.s.fd = fd;
-	c.service = make(map[string]srv);
-	c.pending = make(map[uint64]*RPC);
+	c = new(Client)
+	c.fd = fd
+	c.r.fd = fd
+	c.s.fd = fd
+	c.service = make(map[string]srv)
+	c.pending = make(map[uint64]*RPC)
 
 	// service discovery request
 	m := &msg{
@@ -55,54 +55,54 @@ func NewClient(fd int) (c *Client, err os.Error) {
 		isReq: true,
 		Ret: []interface{}{[]byte(nil)},
 		Size: []int{4000},
-	};
-	m.packRequest();
-	c.s.send(m);
-	m, err = c.r.recv();
+	}
+	m.packRequest()
+	c.s.send(m)
+	m, err = c.r.recv()
 	if err != nil {
 		return nil, err
 	}
-	m.unpackResponse();
+	m.unpackResponse()
 	if m.status != OK {
-		log.Stderrf("NewClient service_discovery: %s", m.status);
-		return nil, m.status;
+		log.Stderrf("NewClient service_discovery: %s", m.status)
+		return nil, m.status
 	}
 	for n, line := range bytes.Split(m.Ret[0].([]byte), []byte{'\n'}, 0) {
-		i := bytes.Index(line, []byte{':'});
+		i := bytes.Index(line, []byte{':'})
 		if i < 0 {
 			continue
 		}
-		c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])};
+		c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])}
 	}
 
-	c.out = make(chan *msg);
-	go c.input();
-	go c.output();
-	return c, nil;
+	c.out = make(chan *msg)
+	go c.input()
+	go c.output()
+	return c, nil
 }
 
 func (c *Client) input() {
 	for {
-		m, err := c.r.recv();
+		m, err := c.r.recv()
 		if err != nil {
 			log.Exitf("client recv: %s", err)
 		}
 		if m.unpackResponse(); m.status != OK {
-			log.Stderrf("invalid message: %s", m.status);
-			continue;
+			log.Stderrf("invalid message: %s", m.status)
+			continue
 		}
-		c.mu.Lock();
-		rpc, ok := c.pending[m.requestId];
+		c.mu.Lock()
+		rpc, ok := c.pending[m.requestId]
 		if ok {
 			c.pending[m.requestId] = nil, false
 		}
-		c.mu.Unlock();
+		c.mu.Unlock()
 		if !ok {
-			log.Stderrf("unexpected response");
-			continue;
+			log.Stderrf("unexpected response")
+			continue
 		}
-		rpc.Ret = m.Ret;
-		rpc.Done <- rpc;
+		rpc.Ret = m.Ret
+		rpc.Done <- rpc
 	}
 }
 
@@ -117,11 +117,11 @@ func (c *Client) NewRPC(done chan *RPC) *RPC {
 	if done == nil {
 		done = make(chan *RPC)
 	}
-	c.mu.Lock();
-	id := c.idGen;
-	c.idGen++;
-	c.mu.Unlock();
-	return &RPC{nil, done, OK, c, id};
+	c.mu.Lock()
+	id := c.idGen
+	c.idGen++
+	c.mu.Unlock()
+	return &RPC{nil, done, OK, c, id}
 }
 
 // Start issues an RPC request for method name with the given arguments.
@@ -129,25 +129,25 @@ func (c *Client) NewRPC(done chan *RPC) *RPC {
 // To wait for the RPC to finish, receive from r.Done and then
 // inspect r.Ret and r.Errno.
 func (r *RPC) Start(name string, arg []interface{}) {
-	var m msg;
+	var m msg
 
-	r.Errno = OK;
-	r.c.mu.Lock();
-	srv, ok := r.c.service[name];
+	r.Errno = OK
+	r.c.mu.Lock()
+	srv, ok := r.c.service[name]
 	if !ok {
-		r.c.mu.Unlock();
-		r.Errno = ErrBadRPCNumber;
-		r.Done <- r;
-		return;
+		r.c.mu.Unlock()
+		r.Errno = ErrBadRPCNumber
+		r.Done <- r
+		return
 	}
-	r.c.pending[r.id] = r;
-	r.c.mu.Unlock();
+	r.c.pending[r.id] = r
+	r.c.mu.Unlock()
 
-	m.protocol = protocol;
-	m.requestId = r.id;
-	m.isReq = true;
-	m.rpcNumber = srv.num;
-	m.Arg = arg;
+	m.protocol = protocol
+	m.requestId = r.id
+	m.isReq = true
+	m.rpcNumber = srv.num
+	m.Arg = arg
 
 	// Fill in the return values and sizes to generate
 	// the right type chars.  We'll take most any size.
@@ -155,15 +155,15 @@ func (r *RPC) Start(name string, arg []interface{}) {
 	// Skip over input arguments.
 	// We could check them against arg, but the server
 	// will do that anyway.
-	i := 0;
+	i := 0
 	for srv.fmt[i] != ':' {
 		i++
 	}
-	fmt := srv.fmt[i+1:];
+	fmt := srv.fmt[i+1:]
 
 	// Now the return prototypes.
-	m.Ret = make([]interface{}, len(fmt)-i);
-	m.Size = make([]int, len(fmt)-i);
+	m.Ret = make([]interface{}, len(fmt)-i)
+	m.Size = make([]int, len(fmt)-i)
 	for i := 0; i < len(fmt); i++ {
 		switch fmt[i] {
 		default:
@@ -171,28 +171,28 @@ func (r *RPC) Start(name string, arg []interface{}) {
 		case 'b':
 			m.Ret[i] = false
 		case 'C':
-			m.Ret[i] = []byte(nil);
-			m.Size[i] = 1 << 30;
+			m.Ret[i] = []byte(nil)
+			m.Size[i] = 1 << 30
 		case 'd':
 			m.Ret[i] = float64(0)
 		case 'D':
-			m.Ret[i] = []float64(nil);
-			m.Size[i] = 1 << 30;
+			m.Ret[i] = []float64(nil)
+			m.Size[i] = 1 << 30
 		case 'h':
 			m.Ret[i] = int(-1)
 		case 'i':
 			m.Ret[i] = int32(0)
 		case 'I':
-			m.Ret[i] = []int32(nil);
-			m.Size[i] = 1 << 30;
+			m.Ret[i] = []int32(nil)
+			m.Size[i] = 1 << 30
 		case 's':
-			m.Ret[i] = "";
-			m.Size[i] = 1 << 30;
+			m.Ret[i] = ""
+			m.Size[i] = 1 << 30
 		}
 	}
 
-	m.packRequest();
-	r.c.out <- &m;
+	m.packRequest()
+	r.c.out <- &m
 }
 
 // Call is a convenient wrapper that starts the RPC request,
@@ -204,7 +204,7 @@ func (r *RPC) Start(name string, arg []interface{}) {
 //	return r.Ret, r.Errno;
 //
 func (r *RPC) Call(name string, arg []interface{}) (ret []interface{}, err Errno) {
-	r.Start(name, arg);
-	<-r.Done;
-	return r.Ret, r.Errno;
+	r.Start(name, arg)
+	<-r.Done
+	return r.Ret, r.Errno
 }