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

4th set of files.

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

1 files changed, 118 insertions, 118 deletions

diff --git a/src/pkg/syscall/syscall_darwin.go b/src/pkg/syscall/syscall_darwin.go
index bb28bc1e9..20f9fa24e 100644
--- a/src/pkg/syscall/syscall_darwin.go
+++ b/src/pkg/syscall/syscall_darwin.go
@@ -23,7 +23,7 @@ const OS = "darwin"
 // even linking this function into the binary.  See ../os/getwd.go.
 const ImplementsGetwd = false
 
-func Getwd() (string, int)	{ return "", ENOTSUP }
+func Getwd() (string, int) { return "", ENOTSUP }
 
 
 /*
@@ -34,7 +34,7 @@ func Getwd() (string, int)	{ return "", ENOTSUP }
 //sys	setgroups(ngid int, gid *_Gid_t) (errno int)
 
 func Getgroups() (gids []int, errno int) {
-	n, err := getgroups(0, nil);
+	n, err := getgroups(0, nil)
 	if err != 0 {
 		return nil, errno
 	}
@@ -47,16 +47,16 @@ func Getgroups() (gids []int, errno int) {
 		return nil, EINVAL
 	}
 
-	a := make([]_Gid_t, n);
-	n, err = getgroups(n, &a[0]);
+	a := make([]_Gid_t, n)
+	n, err = getgroups(n, &a[0])
 	if err != 0 {
 		return nil, errno
 	}
-	gids = make([]int, n);
+	gids = make([]int, n)
 	for i, v := range a[0:n] {
 		gids[i] = int(v)
 	}
-	return;
+	return
 }
 
 func Setgroups(gids []int) (errno int) {
@@ -64,11 +64,11 @@ func Setgroups(gids []int) (errno int) {
 		return setgroups(0, nil)
 	}
 
-	a := make([]_Gid_t, len(gids));
+	a := make([]_Gid_t, len(gids))
 	for i, v := range gids {
 		a[i] = _Gid_t(v)
 	}
-	return setgroups(len(a), &a[0]);
+	return setgroups(len(a), &a[0])
 }
 
 // Wait status is 7 bits at bottom, either 0 (exited),
@@ -80,44 +80,44 @@ func Setgroups(gids []int) (errno int) {
 type WaitStatus uint32
 
 const (
-	mask	= 0x7F;
-	core	= 0x80;
-	shift	= 8;
+	mask  = 0x7F
+	core  = 0x80
+	shift = 8
 
-	exited	= 0;
-	stopped	= 0x7F;
+	exited  = 0
+	stopped = 0x7F
 )
 
-func (w WaitStatus) Exited() bool	{ return w&mask == exited }
+func (w WaitStatus) Exited() bool { return w&mask == exited }
 
 func (w WaitStatus) ExitStatus() int {
 	if w&mask != exited {
 		return -1
 	}
-	return int(w >> shift);
+	return int(w >> shift)
 }
 
-func (w WaitStatus) Signaled() bool	{ return w&mask != stopped && w&mask != 0 }
+func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 }
 
 func (w WaitStatus) Signal() int {
-	sig := int(w & mask);
+	sig := int(w & mask)
 	if sig == stopped || sig == 0 {
 		return -1
 	}
-	return sig;
+	return sig
 }
 
-func (w WaitStatus) CoreDump() bool	{ return w.Signaled() && w&core != 0 }
+func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
 
-func (w WaitStatus) Stopped() bool	{ return w&mask == stopped && w>>shift != SIGSTOP }
+func (w WaitStatus) Stopped() bool { return w&mask == stopped && w>>shift != SIGSTOP }
 
-func (w WaitStatus) Continued() bool	{ return w&mask == stopped && w>>shift == SIGSTOP }
+func (w WaitStatus) Continued() bool { return w&mask == stopped && w>>shift == SIGSTOP }
 
 func (w WaitStatus) StopSignal() int {
 	if !w.Stopped() {
 		return -1
 	}
-	return int(w>>shift) & 0xFF;
+	return int(w>>shift) & 0xFF
 }
 
 func (w WaitStatus) TrapCause() int {
@@ -128,12 +128,12 @@ func (w WaitStatus) TrapCause() int {
 //sys	wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, errno int)
 
 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, errno int) {
-	var status _C_int;
-	wpid, errno = wait4(pid, &status, options, rusage);
+	var status _C_int
+	wpid, errno = wait4(pid, &status, options, rusage)
 	if wstatus != nil {
 		*wstatus = WaitStatus(status)
 	}
-	return;
+	return
 }
 
 //sys	pipe() (r int, w int, errno int)
@@ -142,13 +142,13 @@ func Pipe(p []int) (errno int) {
 	if len(p) != 2 {
 		return EINVAL
 	}
-	p[0], p[1], errno = pipe();
-	return;
+	p[0], p[1], errno = pipe()
+	return
 }
 
 func Sleep(ns int64) (errno int) {
-	tv := NsecToTimeval(ns);
-	return Select(0, nil, nil, nil, &tv);
+	tv := NsecToTimeval(ns)
+	return Select(0, nil, nil, nil, &tv)
 }
 
 //sys	accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, errno int)
@@ -165,173 +165,173 @@ func Sleep(ns int64) (errno int) {
 var SocketDisableIPv6 bool
 
 type Sockaddr interface {
-	sockaddr() (ptr uintptr, len _Socklen, errno int);	// lowercase; only we can define Sockaddrs
+	sockaddr() (ptr uintptr, len _Socklen, errno int) // lowercase; only we can define Sockaddrs
 }
 
 type SockaddrInet4 struct {
-	Port	int;
-	Addr	[4]byte;
-	raw	RawSockaddrInet4;
+	Port int
+	Addr [4]byte
+	raw  RawSockaddrInet4
 }
 
 func (sa *SockaddrInet4) sockaddr() (uintptr, _Socklen, int) {
 	if sa.Port < 0 || sa.Port > 0xFFFF {
 		return 0, 0, EINVAL
 	}
-	sa.raw.Len = SizeofSockaddrInet4;
-	sa.raw.Family = AF_INET;
-	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port));
-	p[0] = byte(sa.Port >> 8);
-	p[1] = byte(sa.Port);
+	sa.raw.Len = SizeofSockaddrInet4
+	sa.raw.Family = AF_INET
+	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
+	p[0] = byte(sa.Port >> 8)
+	p[1] = byte(sa.Port)
 	for i := 0; i < len(sa.Addr); i++ {
 		sa.raw.Addr[i] = sa.Addr[i]
 	}
-	return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0;
+	return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0
 }
 
 type SockaddrInet6 struct {
-	Port	int;
-	Addr	[16]byte;
-	raw	RawSockaddrInet6;
+	Port int
+	Addr [16]byte
+	raw  RawSockaddrInet6
 }
 
 func (sa *SockaddrInet6) sockaddr() (uintptr, _Socklen, int) {
 	if sa.Port < 0 || sa.Port > 0xFFFF {
 		return 0, 0, EINVAL
 	}
-	sa.raw.Len = SizeofSockaddrInet6;
-	sa.raw.Family = AF_INET6;
-	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port));
-	p[0] = byte(sa.Port >> 8);
-	p[1] = byte(sa.Port);
+	sa.raw.Len = SizeofSockaddrInet6
+	sa.raw.Family = AF_INET6
+	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
+	p[0] = byte(sa.Port >> 8)
+	p[1] = byte(sa.Port)
 	for i := 0; i < len(sa.Addr); i++ {
 		sa.raw.Addr[i] = sa.Addr[i]
 	}
-	return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0;
+	return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0
 }
 
 type SockaddrUnix struct {
-	Name	string;
-	raw	RawSockaddrUnix;
+	Name string
+	raw  RawSockaddrUnix
 }
 
 func (sa *SockaddrUnix) sockaddr() (uintptr, _Socklen, int) {
-	name := sa.Name;
-	n := len(name);
+	name := sa.Name
+	n := len(name)
 	if n >= len(sa.raw.Path) || n == 0 {
 		return 0, 0, EINVAL
 	}
-	sa.raw.Len = byte(3 + n);	// 2 for Family, Len; 1 for NUL
-	sa.raw.Family = AF_UNIX;
+	sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
+	sa.raw.Family = AF_UNIX
 	for i := 0; i < n; i++ {
 		sa.raw.Path[i] = int8(name[i])
 	}
-	return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0;
+	return uintptr(unsafe.Pointer(&sa.raw)), _Socklen(sa.raw.Len), 0
 }
 
 func anyToSockaddr(rsa *RawSockaddrAny) (Sockaddr, int) {
 	switch rsa.Addr.Family {
 	case AF_UNIX:
-		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa));
+		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
 		if pp.Len < 3 || pp.Len > SizeofSockaddrUnix {
 			return nil, EINVAL
 		}
-		sa := new(SockaddrUnix);
-		n := int(pp.Len) - 3;	// subtract leading Family, Len, terminating NUL
+		sa := new(SockaddrUnix)
+		n := int(pp.Len) - 3 // subtract leading Family, Len, terminating NUL
 		for i := 0; i < n; i++ {
 			if pp.Path[i] == 0 {
 				// found early NUL; assume Len is overestimating
-				n = i;
-				break;
+				n = i
+				break
 			}
 		}
-		bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]));
-		sa.Name = string(bytes[0:n]);
-		return sa, 0;
+		bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))
+		sa.Name = string(bytes[0:n])
+		return sa, 0
 
 	case AF_INET:
-		pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa));
-		sa := new(SockaddrInet4);
-		p := (*[2]byte)(unsafe.Pointer(&pp.Port));
-		sa.Port = int(p[0])<<8 + int(p[1]);
+		pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
+		sa := new(SockaddrInet4)
+		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
+		sa.Port = int(p[0])<<8 + int(p[1])
 		for i := 0; i < len(sa.Addr); i++ {
 			sa.Addr[i] = pp.Addr[i]
 		}
-		return sa, 0;
+		return sa, 0
 
 	case AF_INET6:
-		pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa));
-		sa := new(SockaddrInet6);
-		p := (*[2]byte)(unsafe.Pointer(&pp.Port));
-		sa.Port = int(p[0])<<8 + int(p[1]);
+		pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
+		sa := new(SockaddrInet6)
+		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
+		sa.Port = int(p[0])<<8 + int(p[1])
 		for i := 0; i < len(sa.Addr); i++ {
 			sa.Addr[i] = pp.Addr[i]
 		}
-		return sa, 0;
+		return sa, 0
 	}
-	return nil, EAFNOSUPPORT;
+	return nil, EAFNOSUPPORT
 }
 
 func Accept(fd int) (nfd int, sa Sockaddr, errno int) {
-	var rsa RawSockaddrAny;
-	var len _Socklen = SizeofSockaddrAny;
-	nfd, errno = accept(fd, &rsa, &len);
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
+	nfd, errno = accept(fd, &rsa, &len)
 	if errno != 0 {
 		return
 	}
-	sa, errno = anyToSockaddr(&rsa);
+	sa, errno = anyToSockaddr(&rsa)
 	if errno != 0 {
-		Close(nfd);
-		nfd = 0;
+		Close(nfd)
+		nfd = 0
 	}
-	return;
+	return
 }
 
 func Getsockname(fd int) (sa Sockaddr, errno int) {
-	var rsa RawSockaddrAny;
-	var len _Socklen = SizeofSockaddrAny;
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
 	if errno = getsockname(fd, &rsa, &len); errno != 0 {
 		return
 	}
-	return anyToSockaddr(&rsa);
+	return anyToSockaddr(&rsa)
 }
 
 func Getpeername(fd int) (sa Sockaddr, errno int) {
-	var rsa RawSockaddrAny;
-	var len _Socklen = SizeofSockaddrAny;
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
 	if errno = getpeername(fd, &rsa, &len); errno != 0 {
 		return
 	}
-	return anyToSockaddr(&rsa);
+	return anyToSockaddr(&rsa)
 }
 
 func Bind(fd int, sa Sockaddr) (errno int) {
-	ptr, n, err := sa.sockaddr();
+	ptr, n, err := sa.sockaddr()
 	if err != 0 {
 		return err
 	}
-	return bind(fd, ptr, n);
+	return bind(fd, ptr, n)
 }
 
 func Connect(fd int, sa Sockaddr) (errno int) {
-	ptr, n, err := sa.sockaddr();
+	ptr, n, err := sa.sockaddr()
 	if err != 0 {
 		return err
 	}
-	return connect(fd, ptr, n);
+	return connect(fd, ptr, n)
 }
 
 func Socket(domain, typ, proto int) (fd, errno int) {
 	if domain == AF_INET6 && SocketDisableIPv6 {
 		return -1, EAFNOSUPPORT
 	}
-	fd, errno = socket(domain, typ, proto);
-	return;
+	fd, errno = socket(domain, typ, proto)
+	return
 }
 
 func SetsockoptInt(fd, level, opt int, value int) (errno int) {
-	var n = int32(value);
-	return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), 4);
+	var n = int32(value)
+	return setsockopt(fd, level, opt, uintptr(unsafe.Pointer(&n)), 4)
 }
 
 func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (errno int) {
@@ -346,44 +346,44 @@ func SetsockoptLinger(fd, level, opt int, l *Linger) (errno int) {
 //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, errno int)
 
 func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, errno int) {
-	var rsa RawSockaddrAny;
-	var len _Socklen = SizeofSockaddrAny;
+	var rsa RawSockaddrAny
+	var len _Socklen = SizeofSockaddrAny
 	if n, errno = recvfrom(fd, p, flags, &rsa, &len); errno != 0 {
 		return
 	}
-	from, errno = anyToSockaddr(&rsa);
-	return;
+	from, errno = anyToSockaddr(&rsa)
+	return
 }
 
 //sys sendto(s int, buf []byte, flags int, to uintptr, addrlen _Socklen) (errno int)
 
 func Sendto(fd int, p []byte, flags int, to Sockaddr) (errno int) {
-	ptr, n, err := to.sockaddr();
+	ptr, n, err := to.sockaddr()
 	if err != 0 {
 		return err
 	}
-	return sendto(fd, p, flags, ptr, n);
+	return sendto(fd, p, flags, ptr, n)
 }
 
 //sys	kevent(kq int, change uintptr, nchange int, event uintptr, nevent int, timeout *Timespec) (n int, errno int)
 
 func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, errno int) {
-	var change, event uintptr;
+	var change, event uintptr
 	if len(changes) > 0 {
 		change = uintptr(unsafe.Pointer(&changes[0]))
 	}
 	if len(events) > 0 {
 		event = uintptr(unsafe.Pointer(&events[0]))
 	}
-	return kevent(kq, change, len(changes), event, len(events), timeout);
+	return kevent(kq, change, len(changes), event, len(events), timeout)
 }
 
 //sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (errno int) = SYS___SYSCTL
 
 // Translate "kern.hostname" to []_C_int{0,1,2,3}.
 func nametomib(name string) (mib []_C_int, errno int) {
-	const CTL_MAXNAME = 12;
-	const siz = uintptr(unsafe.Sizeof(mib[0]));
+	const CTL_MAXNAME = 12
+	const siz = uintptr(unsafe.Sizeof(mib[0]))
 
 	// NOTE(rsc): It seems strange to set the buffer to have
 	// size CTL_MAXNAME+2 but use only CTL_MAXNAME
@@ -392,29 +392,29 @@ func nametomib(name string) (mib []_C_int, errno int) {
 	// I am scared that if we don't include the +2 here, the kernel
 	// will silently write 2 words farther than we specify
 	// and we'll get memory corruption.
-	var buf [CTL_MAXNAME + 2]_C_int;
-	n := uintptr(CTL_MAXNAME) * siz;
+	var buf [CTL_MAXNAME + 2]_C_int
+	n := uintptr(CTL_MAXNAME) * siz
 
-	p := (*byte)(unsafe.Pointer(&buf[0]));
-	bytes := StringByteSlice(name);
+	p := (*byte)(unsafe.Pointer(&buf[0]))
+	bytes := StringByteSlice(name)
 
 	// Magic sysctl: "setting" 0.3 to a string name
 	// lets you read back the array of integers form.
 	if errno = sysctl([]_C_int{0, 3}, p, &n, &bytes[0], uintptr(len(name))); errno != 0 {
 		return nil, errno
 	}
-	return buf[0 : n/siz], 0;
+	return buf[0 : n/siz], 0
 }
 
 func Sysctl(name string) (value string, errno int) {
 	// Translate name to mib number.
-	mib, errno := nametomib(name);
+	mib, errno := nametomib(name)
 	if errno != 0 {
 		return "", errno
 	}
 
 	// Find size.
-	n := uintptr(0);
+	n := uintptr(0)
 	if errno = sysctl(mib, nil, &n, nil, 0); errno != 0 {
 		return "", errno
 	}
@@ -423,7 +423,7 @@ func Sysctl(name string) (value string, errno int) {
 	}
 
 	// Read into buffer of that size.
-	buf := make([]byte, n);
+	buf := make([]byte, n)
 	if errno = sysctl(mib, &buf[0], &n, nil, 0); errno != 0 {
 		return "", errno
 	}
@@ -432,26 +432,26 @@ func Sysctl(name string) (value string, errno int) {
 	if n > 0 && buf[n-1] == '\x00' {
 		n--
 	}
-	return string(buf[0:n]), 0;
+	return string(buf[0:n]), 0
 }
 
 func SysctlUint32(name string) (value uint32, errno int) {
 	// Translate name to mib number.
-	mib, errno := nametomib(name);
+	mib, errno := nametomib(name)
 	if errno != 0 {
 		return 0, errno
 	}
 
 	// Read into buffer of that size.
-	n := uintptr(4);
-	buf := make([]byte, 4);
+	n := uintptr(4)
+	buf := make([]byte, 4)
 	if errno = sysctl(mib, &buf[0], &n, nil, 0); errno != 0 {
 		return 0, errno
 	}
 	if n != 4 {
 		return 0, EIO
 	}
-	return *(*uint32)(unsafe.Pointer(&buf[0])), 0;
+	return *(*uint32)(unsafe.Pointer(&buf[0])), 0
 }
 
 // TODO: wrap