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

23 files changed, 692 insertions, 692 deletions

diff --git a/src/pkg/os/dir_darwin.go b/src/pkg/os/dir_darwin.go
index 9b9d02ea8..7917daec6 100644
--- a/src/pkg/os/dir_darwin.go
+++ b/src/pkg/os/dir_darwin.go
@@ -5,12 +5,12 @@
 package os
 
 import (
-	"syscall";
-	"unsafe";
+	"syscall"
+	"unsafe"
 )
 
 const (
-	blockSize = 4096;	// TODO(r): use statfs
+	blockSize = 4096 // TODO(r): use statfs
 )
 
 // Readdirnames reads the contents of the directory associated with file and
@@ -21,59 +21,59 @@ const (
 func (file *File) Readdirnames(count int) (names []string, err Error) {
 	// If this file has no dirinfo, create one.
 	if file.dirinfo == nil {
-		file.dirinfo = new(dirInfo);
+		file.dirinfo = new(dirInfo)
 		// The buffer must be at least a block long.
 		// TODO(r): use fstatfs to find fs block size.
-		file.dirinfo.buf = make([]byte, blockSize);
+		file.dirinfo.buf = make([]byte, blockSize)
 	}
-	d := file.dirinfo;
-	size := count;
+	d := file.dirinfo
+	size := count
 	if size < 0 {
 		size = 100
 	}
-	names = make([]string, 0, size);	// Empty with room to grow.
+	names = make([]string, 0, size) // Empty with room to grow.
 	for count != 0 {
 		// Refill the buffer if necessary
 		if d.bufp >= d.nbuf {
-			var errno int;
-			d.bufp = 0;
+			var errno int
+			d.bufp = 0
 			// Final argument is (basep *uintptr) and the syscall doesn't take nil.
-			d.nbuf, errno = syscall.Getdirentries(file.fd, d.buf, new(uintptr));
+			d.nbuf, errno = syscall.Getdirentries(file.fd, d.buf, new(uintptr))
 			if errno != 0 {
-				d.nbuf = 0;
-				return names, NewSyscallError("getdirentries", errno);
+				d.nbuf = 0
+				return names, NewSyscallError("getdirentries", errno)
 			}
 			if d.nbuf <= 0 {
-				break	// EOF
+				break // EOF
 			}
 		}
 		// Drain the buffer
 		for count != 0 && d.bufp < d.nbuf {
-			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]));
+			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]))
 			if dirent.Reclen == 0 {
-				d.bufp = d.nbuf;
-				break;
+				d.bufp = d.nbuf
+				break
 			}
-			d.bufp += int(dirent.Reclen);
-			if dirent.Ino == 0 {	// File absent in directory.
+			d.bufp += int(dirent.Reclen)
+			if dirent.Ino == 0 { // File absent in directory.
 				continue
 			}
-			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
-			var name = string(bytes[0:dirent.Namlen]);
-			if name == "." || name == ".." {	// Useless names
+			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+			var name = string(bytes[0:dirent.Namlen])
+			if name == "." || name == ".." { // Useless names
 				continue
 			}
-			count--;
+			count--
 			if len(names) == cap(names) {
-				nnames := make([]string, len(names), 2*len(names));
+				nnames := make([]string, len(names), 2*len(names))
 				for i := 0; i < len(names); i++ {
 					nnames[i] = names[i]
 				}
-				names = nnames;
+				names = nnames
 			}
-			names = names[0 : len(names)+1];
-			names[len(names)-1] = name;
+			names = names[0 : len(names)+1]
+			names[len(names)-1] = name
 		}
 	}
-	return names, nil;
+	return names, nil
 }
diff --git a/src/pkg/os/dir_freebsd.go b/src/pkg/os/dir_freebsd.go
index 34f4b9f13..7a0290ac6 100644
--- a/src/pkg/os/dir_freebsd.go
+++ b/src/pkg/os/dir_freebsd.go
@@ -5,70 +5,70 @@
 package os
 
 import (
-	"syscall";
-	"unsafe";
+	"syscall"
+	"unsafe"
 )
 
 const (
-	blockSize = 4096;	// TODO(r): use statfs
+	blockSize = 4096 // TODO(r): use statfs
 )
 
 func (file *File) Readdirnames(count int) (names []string, err Error) {
 	// If this file has no dirinfo, create one.
 	if file.dirinfo == nil {
-		file.dirinfo = new(dirInfo);
+		file.dirinfo = new(dirInfo)
 		// The buffer must be at least a block long.
 		// TODO(r): use fstatfs to find fs block size.
-		file.dirinfo.buf = make([]byte, blockSize);
+		file.dirinfo.buf = make([]byte, blockSize)
 	}
-	d := file.dirinfo;
-	size := count;
+	d := file.dirinfo
+	size := count
 	if size < 0 {
 		size = 100
 	}
-	names = make([]string, 0, size);	// Empty with room to grow.
+	names = make([]string, 0, size) // Empty with room to grow.
 	for count != 0 {
 		// Refill the buffer if necessary
 		if d.bufp >= d.nbuf {
-			var errno int;
-			d.bufp = 0;
+			var errno int
+			d.bufp = 0
 			// Final argument is (basep *uintptr) and the syscall doesn't take nil.
-			d.nbuf, errno = syscall.Getdirentries(file.fd, d.buf, new(uintptr));
+			d.nbuf, errno = syscall.Getdirentries(file.fd, d.buf, new(uintptr))
 			if errno != 0 {
-				d.nbuf = 0;
-				return names, NewSyscallError("getdirentries", errno);
+				d.nbuf = 0
+				return names, NewSyscallError("getdirentries", errno)
 			}
 			if d.nbuf <= 0 {
-				break	// EOF
+				break // EOF
 			}
 		}
 		// Drain the buffer
 		for count != 0 && d.bufp < d.nbuf {
-			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]));
+			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]))
 			if dirent.Reclen == 0 {
-				d.bufp = d.nbuf;
-				break;
+				d.bufp = d.nbuf
+				break
 			}
-			d.bufp += int(dirent.Reclen);
-			if dirent.Fileno == 0 {	// File absent in directory.
+			d.bufp += int(dirent.Reclen)
+			if dirent.Fileno == 0 { // File absent in directory.
 				continue
 			}
-			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
-			var name = string(bytes[0:dirent.Namlen]);
-			if name == "." || name == ".." {	// Useless names
+			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+			var name = string(bytes[0:dirent.Namlen])
+			if name == "." || name == ".." { // Useless names
 				continue
 			}
-			count--;
+			count--
 			if len(names) == cap(names) {
-				nnames := make([]string, len(names), 2*len(names));
+				nnames := make([]string, len(names), 2*len(names))
 				for i := 0; i < len(names); i++ {
 					nnames[i] = names[i]
 				}
-				names = nnames;
+				names = nnames
 			}
-			names = names[0 : len(names)+1];
-			names[len(names)-1] = name;
+			names = names[0 : len(names)+1]
+			names[len(names)-1] = name
 		}
 	}
-	return names, nil;
+	return names, nil
 }
diff --git a/src/pkg/os/dir_linux.go b/src/pkg/os/dir_linux.go
index 0e73fefd6..e693794f0 100644
--- a/src/pkg/os/dir_linux.go
+++ b/src/pkg/os/dir_linux.go
@@ -5,12 +5,12 @@
 package os
 
 import (
-	"syscall";
-	"unsafe";
+	"syscall"
+	"unsafe"
 )
 
 const (
-	blockSize = 4096;	// TODO(r): use statfs
+	blockSize = 4096 // TODO(r): use statfs
 )
 
 func clen(n []byte) int {
@@ -19,59 +19,59 @@ func clen(n []byte) int {
 			return i
 		}
 	}
-	return len(n);
+	return len(n)
 }
 
 func (file *File) Readdirnames(count int) (names []string, err Error) {
 	// If this file has no dirinfo, create one.
 	if file.dirinfo == nil {
-		file.dirinfo = new(dirInfo);
+		file.dirinfo = new(dirInfo)
 		// The buffer must be at least a block long.
 		// TODO(r): use fstatfs to find fs block size.
-		file.dirinfo.buf = make([]byte, blockSize);
+		file.dirinfo.buf = make([]byte, blockSize)
 	}
-	d := file.dirinfo;
-	size := count;
+	d := file.dirinfo
+	size := count
 	if size < 0 {
 		size = 100
 	}
-	names = make([]string, 0, size);	// Empty with room to grow.
+	names = make([]string, 0, size) // Empty with room to grow.
 	for count != 0 {
 		// Refill the buffer if necessary
 		if d.bufp >= d.nbuf {
-			var errno int;
-			d.nbuf, errno = syscall.Getdents(file.fd, d.buf);
+			var errno int
+			d.nbuf, errno = syscall.Getdents(file.fd, d.buf)
 			if errno != 0 {
 				return names, NewSyscallError("getdents", errno)
 			}
 			if d.nbuf <= 0 {
-				break	// EOF
+				break // EOF
 			}
-			d.bufp = 0;
+			d.bufp = 0
 		}
 		// Drain the buffer
 		for count != 0 && d.bufp < d.nbuf {
-			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]));
-			d.bufp += int(dirent.Reclen);
-			if dirent.Ino == 0 {	// File absent in directory.
+			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]))
+			d.bufp += int(dirent.Reclen)
+			if dirent.Ino == 0 { // File absent in directory.
 				continue
 			}
-			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
-			var name = string(bytes[0:clen(bytes)]);
-			if name == "." || name == ".." {	// Useless names
+			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+			var name = string(bytes[0:clen(bytes)])
+			if name == "." || name == ".." { // Useless names
 				continue
 			}
-			count--;
+			count--
 			if len(names) == cap(names) {
-				nnames := make([]string, len(names), 2*len(names));
+				nnames := make([]string, len(names), 2*len(names))
 				for i := 0; i < len(names); i++ {
 					nnames[i] = names[i]
 				}
-				names = nnames;
+				names = nnames
 			}
-			names = names[0 : len(names)+1];
-			names[len(names)-1] = name;
+			names = names[0 : len(names)+1]
+			names[len(names)-1] = name
 		}
 	}
-	return names, nil;
+	return names, nil
 }
diff --git a/src/pkg/os/dir_nacl.go b/src/pkg/os/dir_nacl.go
index 0e73fefd6..e693794f0 100644
--- a/src/pkg/os/dir_nacl.go
+++ b/src/pkg/os/dir_nacl.go
@@ -5,12 +5,12 @@
 package os
 
 import (
-	"syscall";
-	"unsafe";
+	"syscall"
+	"unsafe"
 )
 
 const (
-	blockSize = 4096;	// TODO(r): use statfs
+	blockSize = 4096 // TODO(r): use statfs
 )
 
 func clen(n []byte) int {
@@ -19,59 +19,59 @@ func clen(n []byte) int {
 			return i
 		}
 	}
-	return len(n);
+	return len(n)
 }
 
 func (file *File) Readdirnames(count int) (names []string, err Error) {
 	// If this file has no dirinfo, create one.
 	if file.dirinfo == nil {
-		file.dirinfo = new(dirInfo);
+		file.dirinfo = new(dirInfo)
 		// The buffer must be at least a block long.
 		// TODO(r): use fstatfs to find fs block size.
-		file.dirinfo.buf = make([]byte, blockSize);
+		file.dirinfo.buf = make([]byte, blockSize)
 	}
-	d := file.dirinfo;
-	size := count;
+	d := file.dirinfo
+	size := count
 	if size < 0 {
 		size = 100
 	}
-	names = make([]string, 0, size);	// Empty with room to grow.
+	names = make([]string, 0, size) // Empty with room to grow.
 	for count != 0 {
 		// Refill the buffer if necessary
 		if d.bufp >= d.nbuf {
-			var errno int;
-			d.nbuf, errno = syscall.Getdents(file.fd, d.buf);
+			var errno int
+			d.nbuf, errno = syscall.Getdents(file.fd, d.buf)
 			if errno != 0 {
 				return names, NewSyscallError("getdents", errno)
 			}
 			if d.nbuf <= 0 {
-				break	// EOF
+				break // EOF
 			}
-			d.bufp = 0;
+			d.bufp = 0
 		}
 		// Drain the buffer
 		for count != 0 && d.bufp < d.nbuf {
-			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]));
-			d.bufp += int(dirent.Reclen);
-			if dirent.Ino == 0 {	// File absent in directory.
+			dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp]))
+			d.bufp += int(dirent.Reclen)
+			if dirent.Ino == 0 { // File absent in directory.
 				continue
 			}
-			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]));
-			var name = string(bytes[0:clen(bytes)]);
-			if name == "." || name == ".." {	// Useless names
+			bytes := (*[len(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
+			var name = string(bytes[0:clen(bytes)])
+			if name == "." || name == ".." { // Useless names
 				continue
 			}
-			count--;
+			count--
 			if len(names) == cap(names) {
-				nnames := make([]string, len(names), 2*len(names));
+				nnames := make([]string, len(names), 2*len(names))
 				for i := 0; i < len(names); i++ {
 					nnames[i] = names[i]
 				}
-				names = nnames;
+				names = nnames
 			}
-			names = names[0 : len(names)+1];
-			names[len(names)-1] = name;
+			names = names[0 : len(names)+1]
+			names[len(names)-1] = name
 		}
 	}
-	return names, nil;
+	return names, nil
 }
diff --git a/src/pkg/os/env.go b/src/pkg/os/env.go
index c1713586d..bdd2ac293 100644
--- a/src/pkg/os/env.go
+++ b/src/pkg/os/env.go
@@ -7,7 +7,7 @@
 package os
 
 import (
-	"once";
+	"once"
 )
 
 // ENOENV is the Error indicating that an environment variable does not exist.
@@ -17,12 +17,12 @@ var env map[string]string
 
 
 func copyenv() {
-	env = make(map[string]string);
+	env = make(map[string]string)
 	for _, s := range Envs {
 		for j := 0; j < len(s); j++ {
 			if s[j] == '=' {
-				env[s[0:j]] = s[j+1:];
-				break;
+				env[s[0:j]] = s[j+1:]
+				break
 			}
 		}
 	}
@@ -31,56 +31,56 @@ func copyenv() {
 // Getenverror retrieves the value of the environment variable named by the key.
 // It returns the value and an error, if any.
 func Getenverror(key string) (value string, err Error) {
-	once.Do(copyenv);
+	once.Do(copyenv)
 
 	if len(key) == 0 {
 		return "", EINVAL
 	}
-	v, ok := env[key];
+	v, ok := env[key]
 	if !ok {
 		return "", ENOENV
 	}
-	return v, nil;
+	return v, nil
 }
 
 // Getenv retrieves the value of the environment variable named by the key.
 // It returns the value, which will be empty if the variable is not present.
 func Getenv(key string) string {
-	v, _ := Getenverror(key);
-	return v;
+	v, _ := Getenverror(key)
+	return v
 }
 
 // Setenv sets the value of the environment variable named by the key.
 // It returns an Error, if any.
 func Setenv(key, value string) Error {
-	once.Do(copyenv);
+	once.Do(copyenv)
 
 	if len(key) == 0 {
 		return EINVAL
 	}
-	env[key] = value;
-	return nil;
+	env[key] = value
+	return nil
 }
 
 // Clearenv deletes all environment variables.
 func Clearenv() {
-	once.Do(copyenv);	// prevent copyenv in Getenv/Setenv
-	env = make(map[string]string);
+	once.Do(copyenv) // prevent copyenv in Getenv/Setenv
+	env = make(map[string]string)
 }
 
 // Environ returns an array of strings representing the environment,
 // in the form "key=value".
 func Environ() []string {
-	once.Do(copyenv);
-	a := make([]string, len(env));
-	i := 0;
+	once.Do(copyenv)
+	a := make([]string, len(env))
+	i := 0
 	for k, v := range env {
 		// check i < len(a) for safety,
 		// in case env is changing underfoot.
 		if i < len(a) {
-			a[i] = k + "=" + v;
-			i++;
+			a[i] = k + "=" + v
+			i++
 		}
 	}
-	return a[0:i];
+	return a[0:i]
 }
diff --git a/src/pkg/os/error.go b/src/pkg/os/error.go
index 34f88de8d..8c53f645a 100644
--- a/src/pkg/os/error.go
+++ b/src/pkg/os/error.go
@@ -8,85 +8,85 @@ import syscall "syscall"
 
 // An Error can represent any printable error condition.
 type Error interface {
-	String() string;
+	String() string
 }
 
 // A helper type that can be embedded or wrapped to simplify satisfying
 // Error.
 type ErrorString string
 
-func (e ErrorString) String() string	{ return string(e) }
+func (e ErrorString) String() string { return string(e) }
 
 // Note: If the name of the function NewError changes,
 // pkg/go/doc/doc.go should be adjusted since it hardwires
 // this name in a heuristic.
 
 // NewError converts s to an ErrorString, which satisfies the Error interface.
-func NewError(s string) Error	{ return ErrorString(s) }
+func NewError(s string) Error { return ErrorString(s) }
 
 // Errno is the Unix error number.  Names such as EINVAL are simple
 // wrappers to convert the error number into an Error.
 type Errno int64
 
-func (e Errno) String() string	{ return syscall.Errstr(int(e)) }
+func (e Errno) String() string { return syscall.Errstr(int(e)) }
 
 // Commonly known Unix errors.
 var (
-	EPERM		Error	= Errno(syscall.EPERM);
-	ENOENT		Error	= Errno(syscall.ENOENT);
-	ESRCH		Error	= Errno(syscall.ESRCH);
-	EINTR		Error	= Errno(syscall.EINTR);
-	EIO		Error	= Errno(syscall.EIO);
-	ENXIO		Error	= Errno(syscall.ENXIO);
-	E2BIG		Error	= Errno(syscall.E2BIG);
-	ENOEXEC		Error	= Errno(syscall.ENOEXEC);
-	EBADF		Error	= Errno(syscall.EBADF);
-	ECHILD		Error	= Errno(syscall.ECHILD);
-	EDEADLK		Error	= Errno(syscall.EDEADLK);
-	ENOMEM		Error	= Errno(syscall.ENOMEM);
-	EACCES		Error	= Errno(syscall.EACCES);
-	EFAULT		Error	= Errno(syscall.EFAULT);
-	EBUSY		Error	= Errno(syscall.EBUSY);
-	EEXIST		Error	= Errno(syscall.EEXIST);
-	EXDEV		Error	= Errno(syscall.EXDEV);
-	ENODEV		Error	= Errno(syscall.ENODEV);
-	ENOTDIR		Error	= Errno(syscall.ENOTDIR);
-	EISDIR		Error	= Errno(syscall.EISDIR);
-	EINVAL		Error	= Errno(syscall.EINVAL);
-	ENFILE		Error	= Errno(syscall.ENFILE);
-	EMFILE		Error	= Errno(syscall.EMFILE);
-	ENOTTY		Error	= Errno(syscall.ENOTTY);
-	EFBIG		Error	= Errno(syscall.EFBIG);
-	ENOSPC		Error	= Errno(syscall.ENOSPC);
-	ESPIPE		Error	= Errno(syscall.ESPIPE);
-	EROFS		Error	= Errno(syscall.EROFS);
-	EMLINK		Error	= Errno(syscall.EMLINK);
-	EPIPE		Error	= Errno(syscall.EPIPE);
-	EAGAIN		Error	= Errno(syscall.EAGAIN);
-	EDOM		Error	= Errno(syscall.EDOM);
-	ERANGE		Error	= Errno(syscall.ERANGE);
-	EADDRINUSE	Error	= Errno(syscall.EADDRINUSE);
-	ECONNREFUSED	Error	= Errno(syscall.ECONNREFUSED);
-	ENAMETOOLONG	Error	= Errno(syscall.ENAMETOOLONG);
-	EAFNOSUPPORT	Error	= Errno(syscall.EAFNOSUPPORT);
+	EPERM        Error = Errno(syscall.EPERM)
+	ENOENT       Error = Errno(syscall.ENOENT)
+	ESRCH        Error = Errno(syscall.ESRCH)
+	EINTR        Error = Errno(syscall.EINTR)
+	EIO          Error = Errno(syscall.EIO)
+	ENXIO        Error = Errno(syscall.ENXIO)
+	E2BIG        Error = Errno(syscall.E2BIG)
+	ENOEXEC      Error = Errno(syscall.ENOEXEC)
+	EBADF        Error = Errno(syscall.EBADF)
+	ECHILD       Error = Errno(syscall.ECHILD)
+	EDEADLK      Error = Errno(syscall.EDEADLK)
+	ENOMEM       Error = Errno(syscall.ENOMEM)
+	EACCES       Error = Errno(syscall.EACCES)
+	EFAULT       Error = Errno(syscall.EFAULT)
+	EBUSY        Error = Errno(syscall.EBUSY)
+	EEXIST       Error = Errno(syscall.EEXIST)
+	EXDEV        Error = Errno(syscall.EXDEV)
+	ENODEV       Error = Errno(syscall.ENODEV)
+	ENOTDIR      Error = Errno(syscall.ENOTDIR)
+	EISDIR       Error = Errno(syscall.EISDIR)
+	EINVAL       Error = Errno(syscall.EINVAL)
+	ENFILE       Error = Errno(syscall.ENFILE)
+	EMFILE       Error = Errno(syscall.EMFILE)
+	ENOTTY       Error = Errno(syscall.ENOTTY)
+	EFBIG        Error = Errno(syscall.EFBIG)
+	ENOSPC       Error = Errno(syscall.ENOSPC)
+	ESPIPE       Error = Errno(syscall.ESPIPE)
+	EROFS        Error = Errno(syscall.EROFS)
+	EMLINK       Error = Errno(syscall.EMLINK)
+	EPIPE        Error = Errno(syscall.EPIPE)
+	EAGAIN       Error = Errno(syscall.EAGAIN)
+	EDOM         Error = Errno(syscall.EDOM)
+	ERANGE       Error = Errno(syscall.ERANGE)
+	EADDRINUSE   Error = Errno(syscall.EADDRINUSE)
+	ECONNREFUSED Error = Errno(syscall.ECONNREFUSED)
+	ENAMETOOLONG Error = Errno(syscall.ENAMETOOLONG)
+	EAFNOSUPPORT Error = Errno(syscall.EAFNOSUPPORT)
 )
 
 // PathError records an error and the operation and file path that caused it.
 type PathError struct {
-	Op	string;
-	Path	string;
-	Error	Error;
+	Op    string
+	Path  string
+	Error Error
 }
 
-func (e *PathError) String() string	{ return e.Op + " " + e.Path + ": " + e.Error.String() }
+func (e *PathError) String() string { return e.Op + " " + e.Path + ": " + e.Error.String() }
 
 // SyscallError records an error from a specific system call.
 type SyscallError struct {
-	Syscall	string;
-	Errno	Errno;
+	Syscall string
+	Errno   Errno
 }
 
-func (e *SyscallError) String() string	{ return e.Syscall + ": " + e.Errno.String() }
+func (e *SyscallError) String() string { return e.Syscall + ": " + e.Errno.String() }
 
 // Note: If the name of the function NewSyscallError changes,
 // pkg/go/doc/doc.go should be adjusted since it hardwires
@@ -99,5 +99,5 @@ func NewSyscallError(syscall string, errno int) Error {
 	if errno == 0 {
 		return nil
 	}
-	return &SyscallError{syscall, Errno(errno)};
+	return &SyscallError{syscall, Errno(errno)}
 }
diff --git a/src/pkg/os/exec.go b/src/pkg/os/exec.go
index 6525f254e..d55acbaa7 100644
--- a/src/pkg/os/exec.go
+++ b/src/pkg/os/exec.go
@@ -5,7 +5,7 @@
 package os
 
 import (
-	"syscall";
+	"syscall"
 )
 
 // ForkExec forks the current process and invokes Exec with the file, arguments,
@@ -17,7 +17,7 @@ import (
 // If dir is not empty, the child chdirs into the directory before execing the program.
 func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*File) (pid int, err Error) {
 	// Create array of integer (system) fds.
-	intfd := make([]int, len(fd));
+	intfd := make([]int, len(fd))
 	for i, f := range fd {
 		if f == nil {
 			intfd[i] = -1
@@ -26,11 +26,11 @@ func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*File
 		}
 	}
 
-	p, e := syscall.ForkExec(argv0, argv, envv, dir, intfd);
+	p, e := syscall.ForkExec(argv0, argv, envv, dir, intfd)
 	if e != 0 {
 		return 0, &PathError{"fork/exec", argv0, Errno(e)}
 	}
-	return p, nil;
+	return p, nil
 }
 
 // Exec replaces the current process with an execution of the program
@@ -41,11 +41,11 @@ func Exec(argv0 string, argv []string, envv []string) Error {
 	if envv == nil {
 		envv = Environ()
 	}
-	e := syscall.Exec(argv0, argv, envv);
+	e := syscall.Exec(argv0, argv, envv)
 	if e != 0 {
 		return &PathError{"exec", argv0, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // TODO(rsc): Should os implement its own syscall.WaitStatus
@@ -57,17 +57,17 @@ func Exec(argv0 string, argv []string, envv []string) Error {
 
 // Waitmsg stores the information about an exited process as reported by Wait.
 type Waitmsg struct {
-	Pid			int;			// The process's id.
-	syscall.WaitStatus;				// System-dependent status info.
-	Rusage			*syscall.Rusage;	// System-dependent resource usage info.
+	Pid                int             // The process's id.
+	syscall.WaitStatus                 // System-dependent status info.
+	Rusage             *syscall.Rusage // System-dependent resource usage info.
 }
 
 // Options for Wait.
 const (
-	WNOHANG		= syscall.WNOHANG;	// Don't wait if no process has exited.
-	WSTOPPED	= syscall.WSTOPPED;	// If set, status of stopped subprocesses is also reported.
-	WUNTRACED	= WSTOPPED;
-	WRUSAGE		= 1 << 20;	// Record resource usage.
+	WNOHANG   = syscall.WNOHANG  // Don't wait if no process has exited.
+	WSTOPPED  = syscall.WSTOPPED // If set, status of stopped subprocesses is also reported.
+	WUNTRACED = WSTOPPED
+	WRUSAGE   = 1 << 20 // Record resource usage.
 )
 
 // WRUSAGE must not be too high a bit, to avoid clashing with Linux's
@@ -78,21 +78,21 @@ const (
 // Waitmsg describing its status and an Error, if any. The options
 // (WNOHANG etc.) affect the behavior of the Wait call.
 func Wait(pid int, options int) (w *Waitmsg, err Error) {
-	var status syscall.WaitStatus;
-	var rusage *syscall.Rusage;
+	var status syscall.WaitStatus
+	var rusage *syscall.Rusage
 	if options&WRUSAGE != 0 {
-		rusage = new(syscall.Rusage);
-		options ^= WRUSAGE;
+		rusage = new(syscall.Rusage)
+		options ^= WRUSAGE
 	}
-	pid1, e := syscall.Wait4(pid, &status, options, rusage);
+	pid1, e := syscall.Wait4(pid, &status, options, rusage)
 	if e != 0 {
 		return nil, NewSyscallError("wait", e)
 	}
-	w = new(Waitmsg);
-	w.Pid = pid1;
-	w.WaitStatus = status;
-	w.Rusage = rusage;
-	return w, nil;
+	w = new(Waitmsg)
+	w.Pid = pid1
+	w.WaitStatus = status
+	w.Rusage = rusage
+	return w, nil
 }
 
 // Convert i to decimal string.
@@ -101,37 +101,37 @@ func itod(i int) string {
 		return "0"
 	}
 
-	u := uint64(i);
+	u := uint64(i)
 	if i < 0 {
 		u = -u
 	}
 
 	// Assemble decimal in reverse order.
-	var b [32]byte;
-	bp := len(b);
+	var b [32]byte
+	bp := len(b)
 	for ; u > 0; u /= 10 {
-		bp--;
-		b[bp] = byte(u%10) + '0';
+		bp--
+		b[bp] = byte(u%10) + '0'
 	}
 
 	if i < 0 {
-		bp--;
-		b[bp] = '-';
+		bp--
+		b[bp] = '-'
 	}
 
-	return string(b[bp:]);
+	return string(b[bp:])
 }
 
 func (w Waitmsg) String() string {
 	// TODO(austin) Use signal names when possible?
-	res := "";
+	res := ""
 	switch {
 	case w.Exited():
 		res = "exit status " + itod(w.ExitStatus())
 	case w.Signaled():
 		res = "signal " + itod(w.Signal())
 	case w.Stopped():
-		res = "stop signal " + itod(w.StopSignal());
+		res = "stop signal " + itod(w.StopSignal())
 		if w.StopSignal() == syscall.SIGTRAP && w.TrapCause() != 0 {
 			res += " (trap " + itod(w.TrapCause()) + ")"
 		}
@@ -141,11 +141,11 @@ func (w Waitmsg) String() string {
 	if w.CoreDump() {
 		res += " (core dumped)"
 	}
-	return res;
+	return res
 }
 
 // Getpid returns the process id of the caller.
-func Getpid() int	{ return syscall.Getpid() }
+func Getpid() int { return syscall.Getpid() }
 
 // Getppid returns the process id of the caller's parent.
-func Getppid() int	{ return syscall.Getppid() }
+func Getppid() int { return syscall.Getppid() }
diff --git a/src/pkg/os/file.go b/src/pkg/os/file.go
index 459b78cc2..87a2925e9 100644
--- a/src/pkg/os/file.go
+++ b/src/pkg/os/file.go
@@ -7,80 +7,80 @@
 package os
 
 import (
-	"syscall";
+	"syscall"
 )
 
 // Auxiliary information if the File describes a directory
 type dirInfo struct {
-	buf	[]byte;	// buffer for directory I/O
-	nbuf	int;	// length of buf; return value from Getdirentries
-	bufp	int;	// location of next record in buf.
+	buf  []byte // buffer for directory I/O
+	nbuf int    // length of buf; return value from Getdirentries
+	bufp int    // location of next record in buf.
 }
 
 // File represents an open file descriptor.
 type File struct {
-	fd	int;
-	name	string;
-	dirinfo	*dirInfo;	// nil unless directory being read
-	nepipe	int;		// number of consecutive EPIPE in Write
+	fd      int
+	name    string
+	dirinfo *dirInfo // nil unless directory being read
+	nepipe  int      // number of consecutive EPIPE in Write
 }
 
 // Fd returns the integer Unix file descriptor referencing the open file.
-func (file *File) Fd() int	{ return file.fd }
+func (file *File) Fd() int { return file.fd }
 
 // Name returns the name of the file as presented to Open.
-func (file *File) Name() string	{ return file.name }
+func (file *File) Name() string { return file.name }
 
 // NewFile returns a new File with the given file descriptor and name.
 func NewFile(fd int, name string) *File {
 	if fd < 0 {
 		return nil
 	}
-	return &File{fd, name, nil, 0};
+	return &File{fd, name, nil, 0}
 }
 
 // Stdin, Stdout, and Stderr are open Files pointing to the standard input,
 // standard output, and standard error file descriptors.
 var (
-	Stdin	= NewFile(0, "/dev/stdin");
-	Stdout	= NewFile(1, "/dev/stdout");
-	Stderr	= NewFile(2, "/dev/stderr");
+	Stdin  = NewFile(0, "/dev/stdin")
+	Stdout = NewFile(1, "/dev/stdout")
+	Stderr = NewFile(2, "/dev/stderr")
 )
 
 // Flags to Open wrapping those of the underlying system. Not all flags
 // may be implemented on a given system.
 const (
-	O_RDONLY	= syscall.O_RDONLY;	// open the file read-only.
-	O_WRONLY	= syscall.O_WRONLY;	// open the file write-only.
-	O_RDWR		= syscall.O_RDWR;	// open the file read-write.
-	O_APPEND	= syscall.O_APPEND;	// open the file append-only.
-	O_ASYNC		= syscall.O_ASYNC;	// generate a signal when I/O is available.
-	O_CREAT		= syscall.O_CREAT;	// create a new file if none exists.
-	O_EXCL		= syscall.O_EXCL;	// used with O_CREAT, file must not exist
-	O_NOCTTY	= syscall.O_NOCTTY;	// do not make file the controlling tty.
-	O_NONBLOCK	= syscall.O_NONBLOCK;	// open in non-blocking mode.
-	O_NDELAY	= O_NONBLOCK;		// synonym for O_NONBLOCK
-	O_SYNC		= syscall.O_SYNC;	// open for synchronous I/O.
-	O_TRUNC		= syscall.O_TRUNC;	// if possible, truncate file when opened.
-	O_CREATE	= O_CREAT;		// create a new file if none exists.
+	O_RDONLY   = syscall.O_RDONLY   // open the file read-only.
+	O_WRONLY   = syscall.O_WRONLY   // open the file write-only.
+	O_RDWR     = syscall.O_RDWR     // open the file read-write.
+	O_APPEND   = syscall.O_APPEND   // open the file append-only.
+	O_ASYNC    = syscall.O_ASYNC    // generate a signal when I/O is available.
+	O_CREAT    = syscall.O_CREAT    // create a new file if none exists.
+	O_EXCL     = syscall.O_EXCL     // used with O_CREAT, file must not exist
+	O_NOCTTY   = syscall.O_NOCTTY   // do not make file the controlling tty.
+	O_NONBLOCK = syscall.O_NONBLOCK // open in non-blocking mode.
+	O_NDELAY   = O_NONBLOCK         // synonym for O_NONBLOCK
+	O_SYNC     = syscall.O_SYNC     // open for synchronous I/O.
+	O_TRUNC    = syscall.O_TRUNC    // if possible, truncate file when opened.
+	O_CREATE   = O_CREAT            // create a new file if none exists.
 )
 
 // Open opens the named file with specified flag (O_RDONLY etc.) and perm, (0666 etc.)
 // if applicable.  If successful, methods on the returned File can be used for I/O.
 // It returns the File and an Error, if any.
 func Open(name string, flag int, perm int) (file *File, err Error) {
-	r, e := syscall.Open(name, flag|syscall.O_CLOEXEC, perm);
+	r, e := syscall.Open(name, flag|syscall.O_CLOEXEC, perm)
 	if e != 0 {
 		return nil, &PathError{"open", name, Errno(e)}
 	}
 
 	// There's a race here with fork/exec, which we are
 	// content to live with.  See ../syscall/exec.go
-	if syscall.O_CLOEXEC == 0 {	// O_CLOEXEC not supported
+	if syscall.O_CLOEXEC == 0 { // O_CLOEXEC not supported
 		syscall.CloseOnExec(r)
 	}
 
-	return NewFile(r, name), nil;
+	return NewFile(r, name), nil
 }
 
 // Close closes the File, rendering it unusable for I/O.
@@ -89,17 +89,17 @@ func (file *File) Close() Error {
 	if file == nil {
 		return EINVAL
 	}
-	var err Error;
+	var err Error
 	if e := syscall.Close(file.fd); e != 0 {
 		err = &PathError{"close", file.name, Errno(e)}
 	}
-	file.fd = -1;	// so it can't be closed again
-	return err;
+	file.fd = -1 // so it can't be closed again
+	return err
 }
 
 type eofError int
 
-func (eofError) String() string	{ return "EOF" }
+func (eofError) String() string { return "EOF" }
 
 // EOF is the Error returned by Read when no more input is available.
 // Functions should return EOF only to signal a graceful end of input.
@@ -115,7 +115,7 @@ func (file *File) Read(b []byte) (n int, err Error) {
 	if file == nil {
 		return 0, EINVAL
 	}
-	n, e := syscall.Read(file.fd, b);
+	n, e := syscall.Read(file.fd, b)
 	if n < 0 {
 		n = 0
 	}
@@ -125,7 +125,7 @@ func (file *File) Read(b []byte) (n int, err Error) {
 	if e != 0 {
 		err = &PathError{"read", file.name, Errno(e)}
 	}
-	return n, err;
+	return n, err
 }
 
 // ReadAt reads len(b) bytes from the File starting at byte offset off.
@@ -137,19 +137,19 @@ func (file *File) ReadAt(b []byte, off int64) (n int, err Error) {
 		return 0, EINVAL
 	}
 	for len(b) > 0 {
-		m, e := syscall.Pread(file.fd, b, off);
+		m, e := syscall.Pread(file.fd, b, off)
 		if m == 0 && e == 0 {
 			return n, EOF
 		}
 		if e != 0 {
-			err = &PathError{"read", file.name, Errno(e)};
-			break;
+			err = &PathError{"read", file.name, Errno(e)}
+			break
 		}
-		n += m;
-		b = b[m:];
-		off += int64(m);
+		n += m
+		b = b[m:]
+		off += int64(m)
 	}
-	return;
+	return
 }
 
 // Write writes len(b) bytes to the File.
@@ -159,12 +159,12 @@ func (file *File) Write(b []byte) (n int, err Error) {
 	if file == nil {
 		return 0, EINVAL
 	}
-	n, e := syscall.Write(file.fd, b);
+	n, e := syscall.Write(file.fd, b)
 	if n < 0 {
 		n = 0
 	}
 	if e == syscall.EPIPE {
-		file.nepipe++;
+		file.nepipe++
 		if file.nepipe >= 10 {
 			Exit(syscall.EPIPE)
 		}
@@ -174,7 +174,7 @@ func (file *File) Write(b []byte) (n int, err Error) {
 	if e != 0 {
 		err = &PathError{"write", file.name, Errno(e)}
 	}
-	return n, err;
+	return n, err
 }
 
 // WriteAt writes len(b) bytes to the File starting at byte offset off.
@@ -185,16 +185,16 @@ func (file *File) WriteAt(b []byte, off int64) (n int, err Error) {
 		return 0, EINVAL
 	}
 	for len(b) > 0 {
-		m, e := syscall.Pwrite(file.fd, b, off);
+		m, e := syscall.Pwrite(file.fd, b, off)
 		if e != 0 {
-			err = &PathError{"write", file.name, Errno(e)};
-			break;
+			err = &PathError{"write", file.name, Errno(e)}
+			break
 		}
-		n += m;
-		b = b[m:];
-		off += int64(m);
+		n += m
+		b = b[m:]
+		off += int64(m)
 	}
-	return;
+	return
 }
 
 // Seek sets the offset for the next Read or Write on file to offset, interpreted
@@ -202,14 +202,14 @@ func (file *File) WriteAt(b []byte, off int64) (n int, err Error) {
 // relative to the current offset, and 2 means relative to the end.
 // It returns the new offset and an Error, if any.
 func (file *File) Seek(offset int64, whence int) (ret int64, err Error) {
-	r, e := syscall.Seek(file.fd, offset, whence);
+	r, e := syscall.Seek(file.fd, offset, whence)
 	if e == 0 && file.dirinfo != nil && r != 0 {
 		e = syscall.EISDIR
 	}
 	if e != 0 {
 		return 0, &PathError{"seek", file.name, Errno(e)}
 	}
-	return r, nil;
+	return r, nil
 }
 
 // WriteString is like Write, but writes the contents of string s rather than
@@ -218,38 +218,38 @@ func (file *File) WriteString(s string) (ret int, err Error) {
 	if file == nil {
 		return 0, EINVAL
 	}
-	b := syscall.StringByteSlice(s);
-	b = b[0 : len(b)-1];
-	return file.Write(b);
+	b := syscall.StringByteSlice(s)
+	b = b[0 : len(b)-1]
+	return file.Write(b)
 }
 
 // Pipe returns a connected pair of Files; reads from r return bytes written to w.
 // It returns the files and an Error, if any.
 func Pipe() (r *File, w *File, err Error) {
-	var p [2]int;
+	var p [2]int
 
 	// See ../syscall/exec.go for description of lock.
-	syscall.ForkLock.RLock();
-	e := syscall.Pipe(&p);
+	syscall.ForkLock.RLock()
+	e := syscall.Pipe(&p)
 	if e != 0 {
-		syscall.ForkLock.RUnlock();
-		return nil, nil, NewSyscallError("pipe", e);
+		syscall.ForkLock.RUnlock()
+		return nil, nil, NewSyscallError("pipe", e)
 	}
-	syscall.CloseOnExec(p[0]);
-	syscall.CloseOnExec(p[1]);
-	syscall.ForkLock.RUnlock();
+	syscall.CloseOnExec(p[0])
+	syscall.CloseOnExec(p[1])
+	syscall.ForkLock.RUnlock()
 
-	return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil;
+	return NewFile(p[0], "|0"), NewFile(p[1], "|1"), nil
 }
 
 // Mkdir creates a new directory with the specified name and permission bits.
 // It returns an error, if any.
 func Mkdir(name string, perm int) Error {
-	e := syscall.Mkdir(name, perm);
+	e := syscall.Mkdir(name, perm)
 	if e != 0 {
 		return &PathError{"mkdir", name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Stat returns a Dir structure describing the named file and an error, if any.
@@ -258,42 +258,42 @@ func Mkdir(name string, perm int) Error {
 // If name names an invalid symbolic link, the returned Dir describes
 // the link itself and has dir.FollowedSymlink set to false.
 func Stat(name string) (dir *Dir, err Error) {
-	var lstat, stat syscall.Stat_t;
-	e := syscall.Lstat(name, &lstat);
+	var lstat, stat syscall.Stat_t
+	e := syscall.Lstat(name, &lstat)
 	if e != 0 {
 		return nil, &PathError{"stat", name, Errno(e)}
 	}
-	statp := &lstat;
+	statp := &lstat
 	if lstat.Mode&syscall.S_IFMT == syscall.S_IFLNK {
-		e := syscall.Stat(name, &stat);
+		e := syscall.Stat(name, &stat)
 		if e == 0 {
 			statp = &stat
 		}
 	}
-	return dirFromStat(name, new(Dir), &lstat, statp), nil;
+	return dirFromStat(name, new(Dir), &lstat, statp), nil
 }
 
 // Stat returns the Dir structure describing file.
 // It returns the Dir and an error, if any.
 func (file *File) Stat() (dir *Dir, err Error) {
-	var stat syscall.Stat_t;
-	e := syscall.Fstat(file.fd, &stat);
+	var stat syscall.Stat_t
+	e := syscall.Fstat(file.fd, &stat)
 	if e != 0 {
 		return nil, &PathError{"stat", file.name, Errno(e)}
 	}
-	return dirFromStat(file.name, new(Dir), &stat, &stat), nil;
+	return dirFromStat(file.name, new(Dir), &stat, &stat), nil
 }
 
 // Lstat returns the Dir structure describing the named file and an error, if any.
 // If the file is a symbolic link, the returned Dir describes the
 // symbolic link.  Lstat makes no attempt to follow the link.
 func Lstat(name string) (dir *Dir, err Error) {
-	var stat syscall.Stat_t;
-	e := syscall.Lstat(name, &stat);
+	var stat syscall.Stat_t
+	e := syscall.Lstat(name, &stat)
 	if e != 0 {
 		return nil, &PathError{"lstat", name, Errno(e)}
 	}
-	return dirFromStat(name, new(Dir), &stat, &stat), nil;
+	return dirFromStat(name, new(Dir), &stat, &stat), nil
 }
 
 // Readdir reads the contents of the directory associated with file and
@@ -302,25 +302,25 @@ func Lstat(name string) (dir *Dir, err Error) {
 // A negative count means to read until EOF.
 // Readdir returns the array and an Error, if any.
 func (file *File) Readdir(count int) (dirs []Dir, err Error) {
-	dirname := file.name;
+	dirname := file.name
 	if dirname == "" {
 		dirname = "."
 	}
-	dirname += "/";
-	names, err1 := file.Readdirnames(count);
+	dirname += "/"
+	names, err1 := file.Readdirnames(count)
 	if err1 != nil {
 		return nil, err1
 	}
-	dirs = make([]Dir, len(names));
+	dirs = make([]Dir, len(names))
 	for i, filename := range names {
-		dirp, err := Lstat(dirname + filename);
+		dirp, err := Lstat(dirname + filename)
 		if dirp == nil || err != nil {
-			dirs[i].Name = filename	// rest is already zeroed out
+			dirs[i].Name = filename // rest is already zeroed out
 		} else {
 			dirs[i] = *dirp
 		}
 	}
-	return;
+	return
 }
 
 // Chdir changes the current working directory to the named directory.
@@ -328,7 +328,7 @@ func Chdir(dir string) Error {
 	if e := syscall.Chdir(dir); e != 0 {
 		return &PathError{"chdir", dir, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Chdir changes the current working directory to the file,
@@ -337,7 +337,7 @@ func (f *File) Chdir() Error {
 	if e := syscall.Fchdir(f.fd); e != 0 {
 		return &PathError{"chdir", f.name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Remove removes the named file or directory.
@@ -346,11 +346,11 @@ func Remove(name string) Error {
 	// whether name is a file or directory.
 	// Try both: it is cheaper on average than
 	// doing a Stat plus the right one.
-	e := syscall.Unlink(name);
+	e := syscall.Unlink(name)
 	if e == 0 {
 		return nil
 	}
-	e1 := syscall.Rmdir(name);
+	e1 := syscall.Rmdir(name)
 	if e1 == 0 {
 		return nil
 	}
@@ -367,16 +367,16 @@ func Remove(name string) Error {
 	if e1 != syscall.ENOTDIR {
 		e = e1
 	}
-	return &PathError{"remove", name, Errno(e)};
+	return &PathError{"remove", name, Errno(e)}
 }
 
 // LinkError records an error during a link or symlink or rename
 // system call and the paths that caused it.
 type LinkError struct {
-	Op	string;
-	Old	string;
-	New	string;
-	Error	Error;
+	Op    string
+	Old   string
+	New   string
+	Error Error
 }
 
 func (e *LinkError) String() string {
@@ -385,28 +385,28 @@ func (e *LinkError) String() string {
 
 // Link creates a hard link.
 func Link(oldname, newname string) Error {
-	e := syscall.Link(oldname, newname);
+	e := syscall.Link(oldname, newname)
 	if e != 0 {
 		return &LinkError{"link", oldname, newname, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Symlink creates a symbolic link.
 func Symlink(oldname, newname string) Error {
-	e := syscall.Symlink(oldname, newname);
+	e := syscall.Symlink(oldname, newname)
 	if e != 0 {
 		return &LinkError{"symlink", oldname, newname, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Readlink reads the contents of a symbolic link: the destination of
 // the link.  It returns the contents and an Error, if any.
 func Readlink(name string) (string, Error) {
 	for len := 128; ; len *= 2 {
-		b := make([]byte, len);
-		n, e := syscall.Readlink(name, b);
+		b := make([]byte, len)
+		n, e := syscall.Readlink(name, b)
 		if e != 0 {
 			return "", &PathError{"readlink", name, Errno(e)}
 		}
@@ -415,16 +415,16 @@ func Readlink(name string) (string, Error) {
 		}
 	}
 	// Silence 6g.
-	return "", nil;
+	return "", nil
 }
 
 // Rename renames a file.
 func Rename(oldname, newname string) Error {
-	e := syscall.Rename(oldname, newname);
+	e := syscall.Rename(oldname, newname)
 	if e != 0 {
 		return &LinkError{"rename", oldname, newname, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Chmod changes the mode of the named file to mode.
@@ -433,7 +433,7 @@ func Chmod(name string, mode int) Error {
 	if e := syscall.Chmod(name, mode); e != 0 {
 		return &PathError{"chmod", name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Chmod changes the mode of the file to mode.
@@ -441,7 +441,7 @@ func (f *File) Chmod(mode int) Error {
 	if e := syscall.Fchmod(f.fd, mode); e != 0 {
 		return &PathError{"chmod", f.name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Chown changes the numeric uid and gid of the named file.
@@ -450,7 +450,7 @@ func Chown(name string, uid, gid int) Error {
 	if e := syscall.Chown(name, uid, gid); e != 0 {
 		return &PathError{"chown", name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Lchown changes the numeric uid and gid of the named file.
@@ -459,7 +459,7 @@ func Lchown(name string, uid, gid int) Error {
 	if e := syscall.Lchown(name, uid, gid); e != 0 {
 		return &PathError{"lchown", name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Chown changes the numeric uid and gid of the named file.
@@ -467,7 +467,7 @@ func (f *File) Chown(uid, gid int) Error {
 	if e := syscall.Fchown(f.fd, uid, gid); e != 0 {
 		return &PathError{"chown", f.name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Truncate changes the size of the named file.
@@ -476,7 +476,7 @@ func Truncate(name string, size int64) Error {
 	if e := syscall.Truncate(name, size); e != 0 {
 		return &PathError{"truncate", name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
 
 // Truncate changes the size of the file.
@@ -485,5 +485,5 @@ func (f *File) Truncate(size int64) Error {
 	if e := syscall.Ftruncate(f.fd, size); e != 0 {
 		return &PathError{"truncate", f.name, Errno(e)}
 	}
-	return nil;
+	return nil
 }
diff --git a/src/pkg/os/getwd.go b/src/pkg/os/getwd.go
index 57f69d12e..49aaea865 100644
--- a/src/pkg/os/getwd.go
+++ b/src/pkg/os/getwd.go
@@ -5,7 +5,7 @@
 package os
 
 import (
-	"syscall";
+	"syscall"
 )
 
 // Getwd returns a rooted path name corresponding to the
@@ -15,21 +15,21 @@ import (
 func Getwd() (string, Error) {
 	// If the operating system provides a Getwd call, use it.
 	if syscall.ImplementsGetwd {
-		s, e := syscall.Getwd();
-		return s, NewSyscallError("getwd", e);
+		s, e := syscall.Getwd()
+		return s, NewSyscallError("getwd", e)
 	}
 
 	// Otherwise, we're trying to find our way back to ".".
-	dot, err := Stat(".");
+	dot, err := Stat(".")
 	if err != nil {
 		return "", err
 	}
 
 	// Clumsy but widespread kludge:
 	// if $PWD is set and matches ".", use it.
-	pwd := Getenv("PWD");
+	pwd := Getenv("PWD")
 	if len(pwd) > 0 && pwd[0] == '/' {
-		d, err := Stat(pwd);
+		d, err := Stat(pwd)
 		if err == nil && d.Dev == dot.Dev && d.Ino == dot.Ino {
 			return pwd, nil
 		}
@@ -37,7 +37,7 @@ func Getwd() (string, Error) {
 
 	// Root is a special case because it has no parent
 	// and ends in a slash.
-	root, err := Stat("/");
+	root, err := Stat("/")
 	if err != nil {
 		// Can't stat root - no hope.
 		return "", err
@@ -49,44 +49,44 @@ func Getwd() (string, Error) {
 	// General algorithm: find name in parent
 	// and then find name of parent.  Each iteration
 	// adds /name to the beginning of pwd.
-	pwd = "";
+	pwd = ""
 	for parent := ".."; ; parent = "../" + parent {
-		if len(parent) >= 1024 {	// Sanity check
+		if len(parent) >= 1024 { // Sanity check
 			return "", ENAMETOOLONG
 		}
-		fd, err := Open(parent, O_RDONLY, 0);
+		fd, err := Open(parent, O_RDONLY, 0)
 		if err != nil {
 			return "", err
 		}
 
 		for {
-			names, err := fd.Readdirnames(100);
+			names, err := fd.Readdirnames(100)
 			if err != nil {
-				fd.Close();
-				return "", err;
+				fd.Close()
+				return "", err
 			}
 			for _, name := range names {
-				d, _ := Lstat(parent + "/" + name);
+				d, _ := Lstat(parent + "/" + name)
 				if d.Dev == dot.Dev && d.Ino == dot.Ino {
-					pwd = "/" + name + pwd;
-					goto Found;
+					pwd = "/" + name + pwd
+					goto Found
 				}
 			}
 		}
-		fd.Close();
-		return "", ENOENT;
+		fd.Close()
+		return "", ENOENT
 
 	Found:
-		pd, err := fd.Stat();
+		pd, err := fd.Stat()
 		if err != nil {
 			return "", err
 		}
-		fd.Close();
+		fd.Close()
 		if pd.Dev == root.Dev && pd.Ino == root.Ino {
 			break
 		}
 		// Set up for next round.
-		dot = pd;
+		dot = pd
 	}
-	return pwd, nil;
+	return pwd, nil
 }
diff --git a/src/pkg/os/os_test.go b/src/pkg/os/os_test.go
index 7ff2bddb3..4523cad79 100644
--- a/src/pkg/os/os_test.go
+++ b/src/pkg/os/os_test.go
@@ -5,13 +5,13 @@
 package os_test
 
 import (
-	"bytes";
-	"fmt";
-	"io";
-	"io/ioutil";
-	. "os";
-	"strings";
-	"testing";
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	. "os"
+	"strings"
+	"testing"
 )
 
 var dot = []string{
@@ -34,16 +34,16 @@ var etc = []string{
 }
 
 func size(name string, t *testing.T) uint64 {
-	file, err := Open(name, O_RDONLY, 0);
-	defer file.Close();
+	file, err := Open(name, O_RDONLY, 0)
+	defer file.Close()
 	if err != nil {
 		t.Fatal("open failed:", err)
 	}
-	var buf [100]byte;
-	len := 0;
+	var buf [100]byte
+	len := 0
 	for {
-		n, e := file.Read(&buf);
-		len += n;
+		n, e := file.Read(&buf)
+		len += n
 		if e == EOF {
 			break
 		}
@@ -51,68 +51,68 @@ func size(name string, t *testing.T) uint64 {
 			t.Fatal("read failed:", err)
 		}
 	}
-	return uint64(len);
+	return uint64(len)
 }
 
 func TestStat(t *testing.T) {
-	dir, err := Stat("/etc/passwd");
+	dir, err := Stat("/etc/passwd")
 	if err != nil {
 		t.Fatal("stat failed:", err)
 	}
 	if dir.Name != "passwd" {
 		t.Error("name should be passwd; is", dir.Name)
 	}
-	filesize := size("/etc/passwd", t);
+	filesize := size("/etc/passwd", t)
 	if dir.Size != filesize {
 		t.Error("size should be", filesize, "; is", dir.Size)
 	}
 }
 
 func TestFstat(t *testing.T) {
-	file, err1 := Open("/etc/passwd", O_RDONLY, 0);
-	defer file.Close();
+	file, err1 := Open("/etc/passwd", O_RDONLY, 0)
+	defer file.Close()
 	if err1 != nil {
 		t.Fatal("open failed:", err1)
 	}
-	dir, err2 := file.Stat();
+	dir, err2 := file.Stat()
 	if err2 != nil {
 		t.Fatal("fstat failed:", err2)
 	}
 	if dir.Name != "passwd" {
 		t.Error("name should be passwd; is", dir.Name)
 	}
-	filesize := size("/etc/passwd", t);
+	filesize := size("/etc/passwd", t)
 	if dir.Size != filesize {
 		t.Error("size should be", filesize, "; is", dir.Size)
 	}
 }
 
 func TestLstat(t *testing.T) {
-	dir, err := Lstat("/etc/passwd");
+	dir, err := Lstat("/etc/passwd")
 	if err != nil {
 		t.Fatal("lstat failed:", err)
 	}
 	if dir.Name != "passwd" {
 		t.Error("name should be passwd; is", dir.Name)
 	}
-	filesize := size("/etc/passwd", t);
+	filesize := size("/etc/passwd", t)
 	if dir.Size != filesize {
 		t.Error("size should be", filesize, "; is", dir.Size)
 	}
 }
 
 func testReaddirnames(dir string, contents []string, t *testing.T) {
-	file, err := Open(dir, O_RDONLY, 0);
-	defer file.Close();
+	file, err := Open(dir, O_RDONLY, 0)
+	defer file.Close()
 	if err != nil {
 		t.Fatalf("open %q failed: %v", dir, err)
 	}
-	s, err2 := file.Readdirnames(-1);
+	s, err2 := file.Readdirnames(-1)
 	if err2 != nil {
 		t.Fatalf("readdirnames %q failed: %v", err2)
 	}
 	for _, m := range contents {
-		found := false;
+		found := false
 		for _, n := range s {
 			if n == "." || n == ".." {
 				t.Errorf("got %s in directory", n)
@@ -121,7 +121,7 @@ func testReaddirnames(dir string, contents []string, t *testing.T) {
 				if found {
 					t.Error("present twice:", m)
 				}
-				found = true;
+				found = true
 			}
 		}
 		if !found {
@@ -131,23 +131,23 @@ func testReaddirnames(dir string, contents []string, t *testing.T) {
 }
 
 func testReaddir(dir string, contents []string, t *testing.T) {
-	file, err := Open(dir, O_RDONLY, 0);
-	defer file.Close();
+	file, err := Open(dir, O_RDONLY, 0)
+	defer file.Close()
 	if err != nil {
 		t.Fatalf("open %q failed: %v", dir, err)
 	}
-	s, err2 := file.Readdir(-1);
+	s, err2 := file.Readdir(-1)
 	if err2 != nil {
 		t.Fatalf("readdir %q failed: %v", dir, err2)
 	}
 	for _, m := range contents {
-		found := false;
+		found := false
 		for _, n := range s {
 			if m == n.Name {
 				if found {
 					t.Error("present twice:", m)
 				}
-				found = true;
+				found = true
 			}
 		}
 		if !found {
@@ -157,51 +157,51 @@ func testReaddir(dir string, contents []string, t *testing.T) {
 }
 
 func TestReaddirnames(t *testing.T) {
-	testReaddirnames(".", dot, t);
-	testReaddirnames("/etc", etc, t);
+	testReaddirnames(".", dot, t)
+	testReaddirnames("/etc", etc, t)
 }
 
 func TestReaddir(t *testing.T) {
-	testReaddir(".", dot, t);
-	testReaddir("/etc", etc, t);
+	testReaddir(".", dot, t)
+	testReaddir("/etc", etc, t)
 }
 
 // Read the directory one entry at a time.
 func smallReaddirnames(file *File, length int, t *testing.T) []string {
-	names := make([]string, length);
-	count := 0;
+	names := make([]string, length)
+	count := 0
 	for {
-		d, err := file.Readdirnames(1);
+		d, err := file.Readdirnames(1)
 		if err != nil {
 			t.Fatalf("readdir %q failed: %v", file.Name(), err)
 		}
 		if len(d) == 0 {
 			break
 		}
-		names[count] = d[0];
-		count++;
+		names[count] = d[0]
+		count++
 	}
-	return names[0:count];
+	return names[0:count]
 }
 
 // Check that reading a directory one entry at a time gives the same result
 // as reading it all at once.
 func TestReaddirnamesOneAtATime(t *testing.T) {
-	dir := "/usr/bin";	// big directory that doesn't change often.
-	file, err := Open(dir, O_RDONLY, 0);
-	defer file.Close();
+	dir := "/usr/bin" // big directory that doesn't change often.
+	file, err := Open(dir, O_RDONLY, 0)
+	defer file.Close()
 	if err != nil {
 		t.Fatalf("open %q failed: %v", dir, err)
 	}
-	all, err1 := file.Readdirnames(-1);
+	all, err1 := file.Readdirnames(-1)
 	if err1 != nil {
 		t.Fatalf("readdirnames %q failed: %v", dir, err1)
 	}
-	file1, err2 := Open(dir, O_RDONLY, 0);
+	file1, err2 := Open(dir, O_RDONLY, 0)
 	if err2 != nil {
 		t.Fatalf("open %q failed: %v", dir, err2)
 	}
-	small := smallReaddirnames(file1, len(all)+100, t);	// +100 in case we screw up
+	small := smallReaddirnames(file1, len(all)+100, t) // +100 in case we screw up
 	for i, n := range all {
 		if small[i] != n {
 			t.Errorf("small read %q %q mismatch: %v", small[i], n)
@@ -210,26 +210,26 @@ func TestReaddirnamesOneAtATime(t *testing.T) {
 }
 
 func TestHardLink(t *testing.T) {
-	from, to := "hardlinktestfrom", "hardlinktestto";
-	Remove(from);	// Just in case.
-	file, err := Open(to, O_CREAT|O_WRONLY, 0666);
+	from, to := "hardlinktestfrom", "hardlinktestto"
+	Remove(from) // Just in case.
+	file, err := Open(to, O_CREAT|O_WRONLY, 0666)
 	if err != nil {
 		t.Fatalf("open %q failed: %v", to, err)
 	}
-	defer Remove(to);
+	defer Remove(to)
 	if err = file.Close(); err != nil {
 		t.Errorf("close %q failed: %v", to, err)
 	}
-	err = Link(to, from);
+	err = Link(to, from)
 	if err != nil {
 		t.Fatalf("link %q, %q failed: %v", to, from, err)
 	}
-	defer Remove(from);
-	tostat, err := Stat(to);
+	defer Remove(from)
+	tostat, err := Stat(to)
 	if err != nil {
 		t.Fatalf("stat %q failed: %v", to, err)
 	}
-	fromstat, err := Stat(from);
+	fromstat, err := Stat(from)
 	if err != nil {
 		t.Fatalf("stat %q failed: %v", from, err)
 	}
@@ -239,74 +239,74 @@ func TestHardLink(t *testing.T) {
 }
 
 func TestSymLink(t *testing.T) {
-	from, to := "symlinktestfrom", "symlinktestto";
-	Remove(from);	// Just in case.
-	file, err := Open(to, O_CREAT|O_WRONLY, 0666);
+	from, to := "symlinktestfrom", "symlinktestto"
+	Remove(from) // Just in case.
+	file, err := Open(to, O_CREAT|O_WRONLY, 0666)
 	if err != nil {
 		t.Fatalf("open %q failed: %v", to, err)
 	}
-	defer Remove(to);
+	defer Remove(to)
 	if err = file.Close(); err != nil {
 		t.Errorf("close %q failed: %v", to, err)
 	}
-	err = Symlink(to, from);
+	err = Symlink(to, from)
 	if err != nil {
 		t.Fatalf("symlink %q, %q failed: %v", to, from, err)
 	}
-	defer Remove(from);
-	tostat, err := Stat(to);
+	defer Remove(from)
+	tostat, err := Stat(to)
 	if err != nil {
 		t.Fatalf("stat %q failed: %v", to, err)
 	}
 	if tostat.FollowedSymlink {
 		t.Fatalf("stat %q claims to have followed a symlink", to)
 	}
-	fromstat, err := Stat(from);
+	fromstat, err := Stat(from)
 	if err != nil {
 		t.Fatalf("stat %q failed: %v", from, err)
 	}
 	if tostat.Dev != fromstat.Dev || tostat.Ino != fromstat.Ino {
 		t.Errorf("symlink %q, %q did not create symlink", to, from)
 	}
-	fromstat, err = Lstat(from);
+	fromstat, err = Lstat(from)
 	if err != nil {
 		t.Fatalf("lstat %q failed: %v", from, err)
 	}
 	if !fromstat.IsSymlink() {
 		t.Fatalf("symlink %q, %q did not create symlink", to, from)
 	}
-	fromstat, err = Stat(from);
+	fromstat, err = Stat(from)
 	if err != nil {
 		t.Fatalf("stat %q failed: %v", from, err)
 	}
 	if !fromstat.FollowedSymlink {
 		t.Fatalf("stat %q did not follow symlink")
 	}
-	s, err := Readlink(from);
+	s, err := Readlink(from)
 	if err != nil {
 		t.Fatalf("readlink %q failed: %v", from, err)
 	}
 	if s != to {
 		t.Fatalf("after symlink %q != %q", s, to)
 	}
-	file, err = Open(from, O_RDONLY, 0);
+	file, err = Open(from, O_RDONLY, 0)
 	if err != nil {
 		t.Fatalf("open %q failed: %v", from, err)
 	}
-	file.Close();
+	file.Close()
 }
 
 func TestLongSymlink(t *testing.T) {
-	s := "0123456789abcdef";
+	s := "0123456789abcdef"
 	// Long, but not too long: a common limit is 255.
-	s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s;
-	from := "longsymlinktestfrom";
-	err := Symlink(s, from);
+	s = s + s + s + s + s + s + s + s + s + s + s + s + s + s + s
+	from := "longsymlinktestfrom"
+	err := Symlink(s, from)
 	if err != nil {
 		t.Fatalf("symlink %q, %q failed: %v", s, from, err)
 	}
-	defer Remove(from);
-	r, err := Readlink(from);
+	defer Remove(from)
+	r, err := Readlink(from)
 	if err != nil {
 		t.Fatalf("readlink %q failed: %v", from, err)
 	}
@@ -316,49 +316,49 @@ func TestLongSymlink(t *testing.T) {
 }
 
 func TestRename(t *testing.T) {
-	from, to := "renamefrom", "renameto";
-	Remove(to);	// Just in case.
-	file, err := Open(from, O_CREAT|O_WRONLY, 0666);
+	from, to := "renamefrom", "renameto"
+	Remove(to) // Just in case.
+	file, err := Open(from, O_CREAT|O_WRONLY, 0666)
 	if err != nil {
 		t.Fatalf("open %q failed: %v", to, err)
 	}
 	if err = file.Close(); err != nil {
 		t.Errorf("close %q failed: %v", to, err)
 	}
-	err = Rename(from, to);
+	err = Rename(from, to)
 	if err != nil {
 		t.Fatalf("rename %q, %q failed: %v", to, from, err)
 	}
-	defer Remove(to);
-	_, err = Stat(to);
+	defer Remove(to)
+	_, err = Stat(to)
 	if err != nil {
 		t.Errorf("stat %q failed: %v", to, err)
 	}
 }
 
 func TestForkExec(t *testing.T) {
-	r, w, err := Pipe();
+	r, w, err := Pipe()
 	if err != nil {
 		t.Fatalf("Pipe: %v", err)
 	}
-	pid, err := ForkExec("/bin/pwd", []string{"pwd"}, nil, "/", []*File{nil, w, Stderr});
+	pid, err := ForkExec("/bin/pwd", []string{"pwd"}, nil, "/", []*File{nil, w, Stderr})
 	if err != nil {
 		t.Fatalf("ForkExec: %v", err)
 	}
-	w.Close();
+	w.Close()
 
-	var b bytes.Buffer;
-	io.Copy(&b, r);
-	output := b.String();
-	expect := "/\n";
+	var b bytes.Buffer
+	io.Copy(&b, r)
+	output := b.String()
+	expect := "/\n"
 	if output != expect {
 		t.Errorf("exec /bin/pwd returned %q wanted %q", output, expect)
 	}
-	Wait(pid, 0);
+	Wait(pid, 0)
 }
 
 func checkMode(t *testing.T, path string, mode uint32) {
-	dir, err := Stat(path);
+	dir, err := Stat(path)
 	if err != nil {
 		t.Fatalf("Stat %q (looking for mode %#o): %s", path, mode, err)
 	}
@@ -368,9 +368,9 @@ func checkMode(t *testing.T, path string, mode uint32) {
 }
 
 func TestChmod(t *testing.T) {
-	MkdirAll("_obj", 0777);
-	const Path = "_obj/_TestChmod_";
-	fd, err := Open(Path, O_WRONLY|O_CREAT, 0666);
+	MkdirAll("_obj", 0777)
+	const Path = "_obj/_TestChmod_"
+	fd, err := Open(Path, O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %s: %s", Path, err)
 	}
@@ -378,19 +378,19 @@ func TestChmod(t *testing.T) {
 	if err = Chmod(Path, 0456); err != nil {
 		t.Fatalf("chmod %s 0456: %s", Path, err)
 	}
-	checkMode(t, Path, 0456);
+	checkMode(t, Path, 0456)
 
 	if err = fd.Chmod(0123); err != nil {
 		t.Fatalf("fchmod %s 0123: %s", Path, err)
 	}
-	checkMode(t, Path, 0123);
+	checkMode(t, Path, 0123)
 
-	fd.Close();
-	Remove(Path);
+	fd.Close()
+	Remove(Path)
 }
 
 func checkUidGid(t *testing.T, path string, uid, gid int) {
-	dir, err := Stat(path);
+	dir, err := Stat(path)
 	if err != nil {
 		t.Fatalf("Stat %q (looking for uid/gid %d/%d): %s", path, uid, gid, err)
 	}
@@ -408,49 +408,49 @@ func TestChown(t *testing.T) {
 	// on the file.  If _obj is on NFS, the Getgroups groups are
 	// basically useless.
 
-	const Path = "/tmp/_TestChown_";
-	fd, err := Open(Path, O_WRONLY|O_CREAT, 0666);
+	const Path = "/tmp/_TestChown_"
+	fd, err := Open(Path, O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %s: %s", Path, err)
 	}
-	dir, err := fd.Stat();
+	dir, err := fd.Stat()
 	if err != nil {
 		t.Fatalf("fstat %s: %s", Path, err)
 	}
-	defer fd.Close();
-	defer Remove(Path);
+	defer fd.Close()
+	defer Remove(Path)
 
 	// Can't change uid unless root, but can try
 	// changing the group id.  First try our current group.
-	gid := Getgid();
-	t.Log("gid:", gid);
+	gid := Getgid()
+	t.Log("gid:", gid)
 	if err = Chown(Path, -1, gid); err != nil {
 		t.Fatalf("chown %s -1 %d: %s", Path, gid, err)
 	}
-	checkUidGid(t, Path, int(dir.Uid), gid);
+	checkUidGid(t, Path, int(dir.Uid), gid)
 
 	// Then try all the auxiliary groups.
-	groups, err := Getgroups();
+	groups, err := Getgroups()
 	if err != nil {
 		t.Fatalf("getgroups: %s", err)
 	}
-	t.Log("groups: ", groups);
+	t.Log("groups: ", groups)
 	for _, g := range groups {
 		if err = Chown(Path, -1, g); err != nil {
 			t.Fatalf("chown %s -1 %d: %s", Path, g, err)
 		}
-		checkUidGid(t, Path, int(dir.Uid), g);
+		checkUidGid(t, Path, int(dir.Uid), g)
 
 		// change back to gid to test fd.Chown
 		if err = fd.Chown(-1, gid); err != nil {
 			t.Fatalf("fchown %s -1 %d: %s", Path, gid, err)
 		}
-		checkUidGid(t, Path, int(dir.Uid), gid);
+		checkUidGid(t, Path, int(dir.Uid), gid)
 	}
 }
 
 func checkSize(t *testing.T, path string, size uint64) {
-	dir, err := Stat(path);
+	dir, err := Stat(path)
 	if err != nil {
 		t.Fatalf("Stat %q (looking for size %d): %s", path, size, err)
 	}
@@ -460,73 +460,73 @@ func checkSize(t *testing.T, path string, size uint64) {
 }
 
 func TestTruncate(t *testing.T) {
-	MkdirAll("_obj", 0777);
-	const Path = "_obj/_TestTruncate_";
-	fd, err := Open(Path, O_WRONLY|O_CREAT, 0666);
+	MkdirAll("_obj", 0777)
+	const Path = "_obj/_TestTruncate_"
+	fd, err := Open(Path, O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %s: %s", Path, err)
 	}
 
-	checkSize(t, Path, 0);
-	fd.Write(strings.Bytes("hello, world\n"));
-	checkSize(t, Path, 13);
-	fd.Truncate(10);
-	checkSize(t, Path, 10);
-	fd.Truncate(1024);
-	checkSize(t, Path, 1024);
-	fd.Truncate(0);
-	checkSize(t, Path, 0);
-	fd.Write(strings.Bytes("surprise!"));
-	checkSize(t, Path, 13+9);	// wrote at offset past where hello, world was.
-	fd.Close();
-	Remove(Path);
+	checkSize(t, Path, 0)
+	fd.Write(strings.Bytes("hello, world\n"))
+	checkSize(t, Path, 13)
+	fd.Truncate(10)
+	checkSize(t, Path, 10)
+	fd.Truncate(1024)
+	checkSize(t, Path, 1024)
+	fd.Truncate(0)
+	checkSize(t, Path, 0)
+	fd.Write(strings.Bytes("surprise!"))
+	checkSize(t, Path, 13+9) // wrote at offset past where hello, world was.
+	fd.Close()
+	Remove(Path)
 }
 
 func TestChdirAndGetwd(t *testing.T) {
-	fd, err := Open(".", O_RDONLY, 0);
+	fd, err := Open(".", O_RDONLY, 0)
 	if err != nil {
 		t.Fatalf("Open .: %s", err)
 	}
 	// These are chosen carefully not to be symlinks on a Mac
 	// (unlike, say, /var, /etc, and /tmp).
-	dirs := []string{"/bin", "/", "/usr/bin"};
+	dirs := []string{"/bin", "/", "/usr/bin"}
 	for mode := 0; mode < 2; mode++ {
 		for _, d := range dirs {
 			if mode == 0 {
 				err = Chdir(d)
 			} else {
-				fd1, err := Open(d, O_RDONLY, 0);
+				fd1, err := Open(d, O_RDONLY, 0)
 				if err != nil {
-					t.Errorf("Open %s: %s", d, err);
-					continue;
+					t.Errorf("Open %s: %s", d, err)
+					continue
 				}
-				err = fd1.Chdir();
-				fd1.Close();
+				err = fd1.Chdir()
+				fd1.Close()
 			}
-			pwd, err1 := Getwd();
-			err2 := fd.Chdir();
+			pwd, err1 := Getwd()
+			err2 := fd.Chdir()
 			if err2 != nil {
 				// We changed the current directory and cannot go back.
 				// Don't let the tests continue; they'll scribble
 				// all over some other directory.
-				fmt.Fprintf(Stderr, "fchdir back to dot failed: %s\n", err2);
-				Exit(1);
+				fmt.Fprintf(Stderr, "fchdir back to dot failed: %s\n", err2)
+				Exit(1)
 			}
 			if err != nil {
-				fd.Close();
-				t.Fatalf("Chdir %s: %s", d, err);
+				fd.Close()
+				t.Fatalf("Chdir %s: %s", d, err)
 			}
 			if err1 != nil {
-				fd.Close();
-				t.Fatalf("Getwd in %s: %s", d, err1);
+				fd.Close()
+				t.Fatalf("Getwd in %s: %s", d, err1)
 			}
 			if pwd != d {
-				fd.Close();
-				t.Fatalf("Getwd returned %q want %q", pwd, d);
+				fd.Close()
+				t.Fatalf("Getwd returned %q want %q", pwd, d)
 			}
 		}
 	}
-	fd.Close();
+	fd.Close()
 }
 
 func TestTime(t *testing.T) {
@@ -536,25 +536,25 @@ func TestTime(t *testing.T) {
 	// filling in the structure passed to the system call.
 	// Too bad the compiler doesn't know that
 	// 365.24*86400 is an integer.
-	sec, nsec, err := Time();
+	sec, nsec, err := Time()
 	if sec < (2009-1970)*36524*864 {
 		t.Errorf("Time() = %d, %d, %s; not plausible", sec, nsec, err)
 	}
 }
 
 func TestSeek(t *testing.T) {
-	f, err := Open("_obj/seektest", O_CREAT|O_RDWR|O_TRUNC, 0666);
+	f, err := Open("_obj/seektest", O_CREAT|O_RDWR|O_TRUNC, 0666)
 	if err != nil {
 		t.Fatalf("open _obj/seektest: %s", err)
 	}
 
-	const data = "hello, world\n";
-	io.WriteString(f, data);
+	const data = "hello, world\n"
+	io.WriteString(f, data)
 
 	type test struct {
-		in	int64;
-		whence	int;
-		out	int64;
+		in     int64
+		whence int
+		out    int64
 	}
 	var tests = []test{
 		test{0, 1, int64(len(data))},
@@ -565,25 +565,25 @@ func TestSeek(t *testing.T) {
 		test{-1, 2, int64(len(data)) - 1},
 		test{1 << 33, 0, 1 << 33},
 		test{1 << 33, 2, 1<<33 + int64(len(data))},
-	};
+	}
 	for i, tt := range tests {
-		off, err := f.Seek(tt.in, tt.whence);
+		off, err := f.Seek(tt.in, tt.whence)
 		if off != tt.out || err != nil {
 			if e, ok := err.(*PathError); ok && e.Error == EINVAL && tt.out > 1<<32 {
 				// Reiserfs rejects the big seeks.
 				// http://code.google.com/p/go/issues/detail?id=91
 				break
 			}
-			t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out);
+			t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
 		}
 	}
-	f.Close();
+	f.Close()
 }
 
 type openErrorTest struct {
-	path	string;
-	mode	int;
-	error	string;
+	path  string
+	mode  int
+	error string
 }
 
 var openErrorTests = []openErrorTest{
@@ -606,11 +606,11 @@ var openErrorTests = []openErrorTest{
 
 func TestOpenError(t *testing.T) {
 	for _, tt := range openErrorTests {
-		f, err := Open(tt.path, tt.mode, 0);
+		f, err := Open(tt.path, tt.mode, 0)
 		if err == nil {
-			t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode);
-			f.Close();
-			continue;
+			t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode)
+			f.Close()
+			continue
 		}
 		if s := err.String(); s != tt.error {
 			t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, s, tt.error)
@@ -620,20 +620,20 @@ func TestOpenError(t *testing.T) {
 
 func run(t *testing.T, cmd []string) string {
 	// Run /bin/hostname and collect output.
-	r, w, err := Pipe();
+	r, w, err := Pipe()
 	if err != nil {
 		t.Fatal(err)
 	}
-	pid, err := ForkExec("/bin/hostname", []string{"hostname"}, nil, "/", []*File{nil, w, Stderr});
+	pid, err := ForkExec("/bin/hostname", []string{"hostname"}, nil, "/", []*File{nil, w, Stderr})
 	if err != nil {
 		t.Fatal(err)
 	}
-	w.Close();
+	w.Close()
 
-	var b bytes.Buffer;
-	io.Copy(&b, r);
-	Wait(pid, 0);
-	output := b.String();
+	var b bytes.Buffer
+	io.Copy(&b, r)
+	Wait(pid, 0)
+	output := b.String()
 	if n := len(output); n > 0 && output[n-1] == '\n' {
 		output = output[0 : n-1]
 	}
@@ -641,32 +641,32 @@ func run(t *testing.T, cmd []string) string {
 		t.Fatalf("%v produced no output", cmd)
 	}
 
-	return output;
+	return output
 }
 
 
 func TestHostname(t *testing.T) {
 	// Check internal Hostname() against the output of /bin/hostname.
-	hostname, err := Hostname();
+	hostname, err := Hostname()
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	want := run(t, []string{"/bin/hostname"});
+	want := run(t, []string{"/bin/hostname"})
 	if hostname != want {
 		t.Errorf("Hostname() = %q, want %q", hostname, want)
 	}
 }
 
 func TestReadAt(t *testing.T) {
-	f, err := Open("_obj/readtest", O_CREAT|O_RDWR|O_TRUNC, 0666);
+	f, err := Open("_obj/readtest", O_CREAT|O_RDWR|O_TRUNC, 0666)
 	if err != nil {
 		t.Fatalf("open _obj/readtest: %s", err)
 	}
-	const data = "hello, world\n";
-	io.WriteString(f, data);
+	const data = "hello, world\n"
+	io.WriteString(f, data)
 
-	b := make([]byte, 5);
-	n, err := f.ReadAt(b, 7);
+	b := make([]byte, 5)
+	n, err := f.ReadAt(b, 7)
 	if err != nil || n != len(b) {
 		t.Fatalf("ReadAt 7: %d, %r", n, err)
 	}
@@ -676,19 +676,19 @@ func TestReadAt(t *testing.T) {
 }
 
 func TestWriteAt(t *testing.T) {
-	f, err := Open("_obj/writetest", O_CREAT|O_RDWR|O_TRUNC, 0666);
+	f, err := Open("_obj/writetest", O_CREAT|O_RDWR|O_TRUNC, 0666)
 	if err != nil {
 		t.Fatalf("open _obj/writetest: %s", err)
 	}
-	const data = "hello, world\n";
-	io.WriteString(f, data);
+	const data = "hello, world\n"
+	io.WriteString(f, data)
 
-	n, err := f.WriteAt(strings.Bytes("WORLD"), 7);
+	n, err := f.WriteAt(strings.Bytes("WORLD"), 7)
 	if err != nil || n != 5 {
 		t.Fatalf("WriteAt 7: %d, %v", n, err)
 	}
 
-	b, err := ioutil.ReadFile("_obj/writetest");
+	b, err := ioutil.ReadFile("_obj/writetest")
 	if err != nil {
 		t.Fatalf("ReadFile _obj/writetest: %v", err)
 	}
diff --git a/src/pkg/os/path.go b/src/pkg/os/path.go
index cdaee92d7..36f497a1a 100644
--- a/src/pkg/os/path.go
+++ b/src/pkg/os/path.go
@@ -14,45 +14,45 @@ package os
 // and returns nil.
 func MkdirAll(path string, perm int) Error {
 	// If path exists, stop with success or error.
-	dir, err := Lstat(path);
+	dir, err := Lstat(path)
 	if err == nil {
 		if dir.IsDirectory() {
 			return nil
 		}
-		return &PathError{"mkdir", path, ENOTDIR};
+		return &PathError{"mkdir", path, ENOTDIR}
 	}
 
 	// Doesn't already exist; make sure parent does.
-	i := len(path);
-	for i > 0 && path[i-1] == '/' {	// Skip trailing slashes.
+	i := len(path)
+	for i > 0 && path[i-1] == '/' { // Skip trailing slashes.
 		i--
 	}
 
-	j := i;
-	for j > 0 && path[j-1] != '/' {	// Scan backward over element.
+	j := i
+	for j > 0 && path[j-1] != '/' { // Scan backward over element.
 		j--
 	}
 
 	if j > 0 {
 		// Create parent
-		err = MkdirAll(path[0:j-1], perm);
+		err = MkdirAll(path[0:j-1], perm)
 		if err != nil {
 			return err
 		}
 	}
 
 	// Now parent exists, try to create.
-	err = Mkdir(path, perm);
+	err = Mkdir(path, perm)
 	if err != nil {
 		// Handle arguments like "foo/." by
 		// double-checking that directory doesn't exist.
-		dir, err1 := Lstat(path);
+		dir, err1 := Lstat(path)
 		if err1 == nil && dir.IsDirectory() {
 			return nil
 		}
-		return err;
+		return err
 	}
-	return nil;
+	return nil
 }
 
 // RemoveAll removes path and any children it contains.
@@ -61,18 +61,18 @@ func MkdirAll(path string, perm int) Error {
 // returns nil (no error).
 func RemoveAll(path string) Error {
 	// Simple case: if Remove works, we're done.
-	err := Remove(path);
+	err := Remove(path)
 	if err == nil {
 		return nil
 	}
 
 	// Otherwise, is this a directory we need to recurse into?
-	dir, serr := Lstat(path);
+	dir, serr := Lstat(path)
 	if serr != nil {
 		if serr, ok := serr.(*PathError); ok && serr.Error == ENOENT {
 			return nil
 		}
-		return serr;
+		return serr
 	}
 	if !dir.IsDirectory() {
 		// Not a directory; return the error from Remove.
@@ -80,18 +80,18 @@ func RemoveAll(path string) Error {
 	}
 
 	// Directory.
-	fd, err := Open(path, O_RDONLY, 0);
+	fd, err := Open(path, O_RDONLY, 0)
 	if err != nil {
 		return err
 	}
-	defer fd.Close();
+	defer fd.Close()
 
 	// Remove contents & return first error.
-	err = nil;
+	err = nil
 	for {
-		names, err1 := fd.Readdirnames(100);
+		names, err1 := fd.Readdirnames(100)
 		for _, name := range names {
-			err1 := RemoveAll(path + "/" + name);
+			err1 := RemoveAll(path + "/" + name)
 			if err == nil {
 				err = err1
 			}
@@ -106,9 +106,9 @@ func RemoveAll(path string) Error {
 	}
 
 	// Remove directory.
-	err1 := Remove(path);
+	err1 := Remove(path)
 	if err == nil {
 		err = err1
 	}
-	return err;
+	return err
 }
diff --git a/src/pkg/os/path_test.go b/src/pkg/os/path_test.go
index 9b01bd5b6..fcd4bac54 100644
--- a/src/pkg/os/path_test.go
+++ b/src/pkg/os/path_test.go
@@ -5,38 +5,38 @@
 package os_test
 
 import (
-	. "os";
-	"testing";
+	. "os"
+	"testing"
 )
 
 func TestMkdirAll(t *testing.T) {
 	// Create new dir, in _obj so it will get
 	// cleaned up by make if not by us.
-	path := "_obj/_TestMkdirAll_/dir/./dir2";
-	err := MkdirAll(path, 0777);
+	path := "_obj/_TestMkdirAll_/dir/./dir2"
+	err := MkdirAll(path, 0777)
 	if err != nil {
 		t.Fatalf("MkdirAll %q: %s", path, err)
 	}
 
 	// Already exists, should succeed.
-	err = MkdirAll(path, 0777);
+	err = MkdirAll(path, 0777)
 	if err != nil {
 		t.Fatalf("MkdirAll %q (second time): %s", path, err)
 	}
 
 	// Make file.
-	fpath := path + "/file";
-	_, err = Open(fpath, O_WRONLY|O_CREAT, 0666);
+	fpath := path + "/file"
+	_, err = Open(fpath, O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %q: %s", fpath, err)
 	}
 
 	// Can't make directory named after file.
-	err = MkdirAll(fpath, 0777);
+	err = MkdirAll(fpath, 0777)
 	if err == nil {
 		t.Fatalf("MkdirAll %q: no error")
 	}
-	perr, ok := err.(*PathError);
+	perr, ok := err.(*PathError)
 	if !ok {
 		t.Fatalf("MkdirAll %q returned %T, not *PathError", fpath, err)
 	}
@@ -45,12 +45,12 @@ func TestMkdirAll(t *testing.T) {
 	}
 
 	// Can't make subdirectory of file.
-	ffpath := fpath + "/subdir";
-	err = MkdirAll(ffpath, 0777);
+	ffpath := fpath + "/subdir"
+	err = MkdirAll(ffpath, 0777)
 	if err == nil {
 		t.Fatalf("MkdirAll %q: no error")
 	}
-	perr, ok = err.(*PathError);
+	perr, ok = err.(*PathError)
 	if !ok {
 		t.Fatalf("MkdirAll %q returned %T, not *PathError", ffpath, err)
 	}
@@ -58,24 +58,24 @@ func TestMkdirAll(t *testing.T) {
 		t.Fatalf("MkdirAll %q returned wrong error path: %q not %q", ffpath, perr.Path, fpath)
 	}
 
-	RemoveAll("_obj/_TestMkdirAll_");
+	RemoveAll("_obj/_TestMkdirAll_")
 }
 
 func TestRemoveAll(t *testing.T) {
 	// Work directory.
-	path := "_obj/_TestRemoveAll_";
-	fpath := path + "/file";
-	dpath := path + "/dir";
+	path := "_obj/_TestRemoveAll_"
+	fpath := path + "/file"
+	dpath := path + "/dir"
 
 	// Make directory with 1 file and remove.
 	if err := MkdirAll(path, 0777); err != nil {
 		t.Fatalf("MkdirAll %q: %s", path, err)
 	}
-	fd, err := Open(fpath, O_WRONLY|O_CREAT, 0666);
+	fd, err := Open(fpath, O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %q: %s", fpath, err)
 	}
-	fd.Close();
+	fd.Close()
 	if err = RemoveAll(path); err != nil {
 		t.Fatalf("RemoveAll %q (first): %s", path, err)
 	}
@@ -87,16 +87,16 @@ func TestRemoveAll(t *testing.T) {
 	if err = MkdirAll(dpath, 0777); err != nil {
 		t.Fatalf("MkdirAll %q: %s", dpath, err)
 	}
-	fd, err = Open(fpath, O_WRONLY|O_CREAT, 0666);
+	fd, err = Open(fpath, O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %q: %s", fpath, err)
 	}
-	fd.Close();
-	fd, err = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666);
+	fd.Close()
+	fd, err = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
 	if err != nil {
 		t.Fatalf("create %q: %s", fpath, err)
 	}
-	fd.Close();
+	fd.Close()
 	if err = RemoveAll(path); err != nil {
 		t.Fatalf("RemoveAll %q (second): %s", path, err)
 	}
@@ -104,30 +104,30 @@ func TestRemoveAll(t *testing.T) {
 		t.Fatalf("Lstat %q succeeded after RemoveAll (second)", path)
 	}
 
-	if Getuid() != 0 {	// Test fails as root
+	if Getuid() != 0 { // Test fails as root
 		// Make directory with file and subdirectory and trigger error.
 		if err = MkdirAll(dpath, 0777); err != nil {
 			t.Fatalf("MkdirAll %q: %s", dpath, err)
 		}
 
 		for _, s := range []string{fpath, dpath + "/file1", path + "/zzz"} {
-			fd, err = Open(s, O_WRONLY|O_CREAT, 0666);
+			fd, err = Open(s, O_WRONLY|O_CREAT, 0666)
 			if err != nil {
 				t.Fatalf("create %q: %s", s, err)
 			}
-			fd.Close();
+			fd.Close()
 		}
 		if err = Chmod(dpath, 0); err != nil {
 			t.Fatalf("Chmod %q 0: %s", dpath, err)
 		}
 		if err = RemoveAll(path); err == nil {
-			_, err := Lstat(path);
+			_, err := Lstat(path)
 			if err == nil {
 				t.Errorf("Can lstat %q after supposed RemoveAll", path)
 			}
-			t.Fatalf("RemoveAll %q succeeded with chmod 0 subdirectory", path, err);
+			t.Fatalf("RemoveAll %q succeeded with chmod 0 subdirectory", path, err)
 		}
-		perr, ok := err.(*PathError);
+		perr, ok := err.(*PathError)
 		if !ok {
 			t.Fatalf("RemoveAll %q returned %T not *PathError", path, err)
 		}
diff --git a/src/pkg/os/proc.go b/src/pkg/os/proc.go
index e780cfc9a..dfddab6cb 100644
--- a/src/pkg/os/proc.go
+++ b/src/pkg/os/proc.go
@@ -8,28 +8,28 @@ package os
 
 import "syscall"
 
-var Args []string	// provided by runtime
-var Envs []string	// provided by runtime
+var Args []string // provided by runtime
+var Envs []string // provided by runtime
 
 
 // Getuid returns the numeric user id of the caller.
-func Getuid() int	{ return syscall.Getuid() }
+func Getuid() int { return syscall.Getuid() }
 
 // Geteuid returns the numeric effective user id of the caller.
-func Geteuid() int	{ return syscall.Geteuid() }
+func Geteuid() int { return syscall.Geteuid() }
 
 // Getgid returns the numeric group id of the caller.
-func Getgid() int	{ return syscall.Getgid() }
+func Getgid() int { return syscall.Getgid() }
 
 // Getegid returns the numeric effective group id of the caller.
-func Getegid() int	{ return syscall.Getegid() }
+func Getegid() int { return syscall.Getegid() }
 
 // Getgroups returns a list of the numeric ids of groups that the caller belongs to.
 func Getgroups() ([]int, Error) {
-	gids, errno := syscall.Getgroups();
-	return gids, NewSyscallError("getgroups", errno);
+	gids, errno := syscall.Getgroups()
+	return gids, NewSyscallError("getgroups", errno)
 }
 
 // Exit causes the current program to exit with the given status code.
 // Conventionally, code zero indicates success, non-zero an error.
-func Exit(code int)	{ syscall.Exit(code) }
+func Exit(code int) { syscall.Exit(code) }
diff --git a/src/pkg/os/stat_darwin.go b/src/pkg/os/stat_darwin.go
index 857c9068d..003a45351 100644
--- a/src/pkg/os/stat_darwin.go
+++ b/src/pkg/os/stat_darwin.go
@@ -11,28 +11,28 @@ func isSymlink(stat *syscall.Stat_t) bool {
 }
 
 func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
-	dir.Dev = uint64(stat.Dev);
-	dir.Ino = stat.Ino;
-	dir.Nlink = uint64(stat.Nlink);
-	dir.Mode = uint32(stat.Mode);
-	dir.Uid = stat.Uid;
-	dir.Gid = stat.Gid;
-	dir.Rdev = uint64(stat.Rdev);
-	dir.Size = uint64(stat.Size);
-	dir.Blksize = uint64(stat.Blksize);
-	dir.Blocks = uint64(stat.Blocks);
-	dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec));
-	dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec));
-	dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec));
+	dir.Dev = uint64(stat.Dev)
+	dir.Ino = stat.Ino
+	dir.Nlink = uint64(stat.Nlink)
+	dir.Mode = uint32(stat.Mode)
+	dir.Uid = stat.Uid
+	dir.Gid = stat.Gid
+	dir.Rdev = uint64(stat.Rdev)
+	dir.Size = uint64(stat.Size)
+	dir.Blksize = uint64(stat.Blksize)
+	dir.Blocks = uint64(stat.Blocks)
+	dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec))
+	dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec))
+	dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec))
 	for i := len(name) - 1; i >= 0; i-- {
 		if name[i] == '/' {
-			name = name[i+1:];
-			break;
+			name = name[i+1:]
+			break
 		}
 	}
-	dir.Name = name;
+	dir.Name = name
 	if isSymlink(lstat) && !isSymlink(stat) {
 		dir.FollowedSymlink = true
 	}
-	return dir;
+	return dir
 }
diff --git a/src/pkg/os/stat_freebsd.go b/src/pkg/os/stat_freebsd.go
index c28f97689..84a6c7859 100644
--- a/src/pkg/os/stat_freebsd.go
+++ b/src/pkg/os/stat_freebsd.go
@@ -11,28 +11,28 @@ func isSymlink(stat *syscall.Stat_t) bool {
 }
 
 func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
-	dir.Dev = uint64(stat.Dev);
-	dir.Ino = uint64(stat.Ino);
-	dir.Nlink = uint64(stat.Nlink);
-	dir.Mode = uint32(stat.Mode);
-	dir.Uid = stat.Uid;
-	dir.Gid = stat.Gid;
-	dir.Rdev = uint64(stat.Rdev);
-	dir.Size = uint64(stat.Size);
-	dir.Blksize = uint64(stat.Blksize);
-	dir.Blocks = uint64(stat.Blocks);
-	dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec));
-	dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec));
-	dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec));
+	dir.Dev = uint64(stat.Dev)
+	dir.Ino = uint64(stat.Ino)
+	dir.Nlink = uint64(stat.Nlink)
+	dir.Mode = uint32(stat.Mode)
+	dir.Uid = stat.Uid
+	dir.Gid = stat.Gid
+	dir.Rdev = uint64(stat.Rdev)
+	dir.Size = uint64(stat.Size)
+	dir.Blksize = uint64(stat.Blksize)
+	dir.Blocks = uint64(stat.Blocks)
+	dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atimespec))
+	dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtimespec))
+	dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctimespec))
 	for i := len(name) - 1; i >= 0; i-- {
 		if name[i] == '/' {
-			name = name[i+1:];
-			break;
+			name = name[i+1:]
+			break
 		}
 	}
-	dir.Name = name;
+	dir.Name = name
 	if isSymlink(lstat) && !isSymlink(stat) {
 		dir.FollowedSymlink = true
 	}
-	return dir;
+	return dir
 }
diff --git a/src/pkg/os/stat_linux.go b/src/pkg/os/stat_linux.go
index a947b5802..362fae48b 100644
--- a/src/pkg/os/stat_linux.go
+++ b/src/pkg/os/stat_linux.go
@@ -11,28 +11,28 @@ func isSymlink(stat *syscall.Stat_t) bool {
 }
 
 func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
-	dir.Dev = stat.Dev;
-	dir.Ino = uint64(stat.Ino);
-	dir.Nlink = uint64(stat.Nlink);
-	dir.Mode = stat.Mode;
-	dir.Uid = stat.Uid;
-	dir.Gid = stat.Gid;
-	dir.Rdev = stat.Rdev;
-	dir.Size = uint64(stat.Size);
-	dir.Blksize = uint64(stat.Blksize);
-	dir.Blocks = uint64(stat.Blocks);
-	dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atim));
-	dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtim));
-	dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctim));
+	dir.Dev = stat.Dev
+	dir.Ino = uint64(stat.Ino)
+	dir.Nlink = uint64(stat.Nlink)
+	dir.Mode = stat.Mode
+	dir.Uid = stat.Uid
+	dir.Gid = stat.Gid
+	dir.Rdev = stat.Rdev
+	dir.Size = uint64(stat.Size)
+	dir.Blksize = uint64(stat.Blksize)
+	dir.Blocks = uint64(stat.Blocks)
+	dir.Atime_ns = uint64(syscall.TimespecToNsec(stat.Atim))
+	dir.Mtime_ns = uint64(syscall.TimespecToNsec(stat.Mtim))
+	dir.Ctime_ns = uint64(syscall.TimespecToNsec(stat.Ctim))
 	for i := len(name) - 1; i >= 0; i-- {
 		if name[i] == '/' {
-			name = name[i+1:];
-			break;
+			name = name[i+1:]
+			break
 		}
 	}
-	dir.Name = name;
+	dir.Name = name
 	if isSymlink(lstat) && !isSymlink(stat) {
 		dir.FollowedSymlink = true
 	}
-	return dir;
+	return dir
 }
diff --git a/src/pkg/os/stat_nacl.go b/src/pkg/os/stat_nacl.go
index 8cad9c944..65f49c886 100644
--- a/src/pkg/os/stat_nacl.go
+++ b/src/pkg/os/stat_nacl.go
@@ -11,28 +11,28 @@ func isSymlink(stat *syscall.Stat_t) bool {
 }
 
 func dirFromStat(name string, dir *Dir, lstat, stat *syscall.Stat_t) *Dir {
-	dir.Dev = uint64(stat.Dev);
-	dir.Ino = uint64(stat.Ino);
-	dir.Nlink = uint64(stat.Nlink);
-	dir.Mode = stat.Mode;
-	dir.Uid = stat.Uid;
-	dir.Gid = stat.Gid;
-	dir.Rdev = uint64(stat.Rdev);
-	dir.Size = uint64(stat.Size);
-	dir.Blksize = uint64(stat.Blksize);
-	dir.Blocks = uint64(stat.Blocks);
-	dir.Atime_ns = uint64(stat.Atime) * 1e9;
-	dir.Mtime_ns = uint64(stat.Mtime) * 1e9;
-	dir.Ctime_ns = uint64(stat.Ctime) * 1e9;
+	dir.Dev = uint64(stat.Dev)
+	dir.Ino = uint64(stat.Ino)
+	dir.Nlink = uint64(stat.Nlink)
+	dir.Mode = stat.Mode
+	dir.Uid = stat.Uid
+	dir.Gid = stat.Gid
+	dir.Rdev = uint64(stat.Rdev)
+	dir.Size = uint64(stat.Size)
+	dir.Blksize = uint64(stat.Blksize)
+	dir.Blocks = uint64(stat.Blocks)
+	dir.Atime_ns = uint64(stat.Atime) * 1e9
+	dir.Mtime_ns = uint64(stat.Mtime) * 1e9
+	dir.Ctime_ns = uint64(stat.Ctime) * 1e9
 	for i := len(name) - 1; i >= 0; i-- {
 		if name[i] == '/' {
-			name = name[i+1:];
-			break;
+			name = name[i+1:]
+			break
 		}
 	}
-	dir.Name = name;
+	dir.Name = name
 	if isSymlink(lstat) && !isSymlink(stat) {
 		dir.FollowedSymlink = true
 	}
-	return dir;
+	return dir
 }
diff --git a/src/pkg/os/sys_darwin.go b/src/pkg/os/sys_darwin.go
index c92845578..2e3ab2127 100644
--- a/src/pkg/os/sys_darwin.go
+++ b/src/pkg/os/sys_darwin.go
@@ -9,10 +9,10 @@ package os
 import "syscall"
 
 func Hostname() (name string, err Error) {
-	var errno int;
-	name, errno = syscall.Sysctl("kern.hostname");
+	var errno int
+	name, errno = syscall.Sysctl("kern.hostname")
 	if errno != 0 {
 		return "", NewSyscallError("sysctl kern.hostname", errno)
 	}
-	return name, nil;
+	return name, nil
 }
diff --git a/src/pkg/os/sys_freebsd.go b/src/pkg/os/sys_freebsd.go
index cc8daeca3..c567f5c35 100644
--- a/src/pkg/os/sys_freebsd.go
+++ b/src/pkg/os/sys_freebsd.go
@@ -7,10 +7,10 @@ package os
 import "syscall"
 
 func Hostname() (name string, err Error) {
-	var errno int;
-	name, errno = syscall.Sysctl("kern.hostname");
+	var errno int
+	name, errno = syscall.Sysctl("kern.hostname")
 	if errno != 0 {
 		return "", NewSyscallError("sysctl kern.hostname", errno)
 	}
-	return name, nil;
+	return name, nil
 }
diff --git a/src/pkg/os/sys_linux.go b/src/pkg/os/sys_linux.go
index 896be164d..0622b6712 100644
--- a/src/pkg/os/sys_linux.go
+++ b/src/pkg/os/sys_linux.go
@@ -9,14 +9,14 @@ package os
 
 // Hostname returns the host name reported by the kernel.
 func Hostname() (name string, err Error) {
-	f, err := Open("/proc/sys/kernel/hostname", O_RDONLY, 0);
+	f, err := Open("/proc/sys/kernel/hostname", O_RDONLY, 0)
 	if err != nil {
 		return "", err
 	}
-	defer f.Close();
+	defer f.Close()
 
-	var buf [512]byte;	// Enough for a DNS name.
-	n, err := f.Read(&buf);
+	var buf [512]byte // Enough for a DNS name.
+	n, err := f.Read(&buf)
 	if err != nil {
 		return "", err
 	}
@@ -24,5 +24,5 @@ func Hostname() (name string, err Error) {
 	if n > 0 && buf[n-1] == '\n' {
 		n--
 	}
-	return string(buf[0:n]), nil;
+	return string(buf[0:n]), nil
 }
diff --git a/src/pkg/os/sys_nacl.go b/src/pkg/os/sys_nacl.go
index 51694a046..dfcccb3e8 100644
--- a/src/pkg/os/sys_nacl.go
+++ b/src/pkg/os/sys_nacl.go
@@ -4,4 +4,4 @@
 
 package os
 
-func Hostname() (name string, err Error)	{ return "nacl", nil }
+func Hostname() (name string, err Error) { return "nacl", nil }
diff --git a/src/pkg/os/time.go b/src/pkg/os/time.go
index 2510b8586..380345f1b 100644
--- a/src/pkg/os/time.go
+++ b/src/pkg/os/time.go
@@ -12,9 +12,9 @@ import "syscall"
 // time is thus 1e9*sec+nsec, in nanoseconds.  The zero of
 // time is the Unix epoch.
 func Time() (sec int64, nsec int64, err Error) {
-	var tv syscall.Timeval;
+	var tv syscall.Timeval
 	if errno := syscall.Gettimeofday(&tv); errno != 0 {
 		return 0, 0, NewSyscallError("gettimeofday", errno)
 	}
-	return int64(tv.Sec), int64(tv.Usec) * 1000, err;
+	return int64(tv.Sec), int64(tv.Usec) * 1000, err
 }
diff --git a/src/pkg/os/types.go b/src/pkg/os/types.go
index ec3b4e11b..673b7f788 100644
--- a/src/pkg/os/types.go
+++ b/src/pkg/os/types.go
@@ -10,47 +10,47 @@ import "syscall"
 // OS-specific routines in this directory convert the OS-local versions to these.
 
 // Getpagesize returns the underlying system's memory page size.
-func Getpagesize() int	{ return syscall.Getpagesize() }
+func Getpagesize() int { return syscall.Getpagesize() }
 
 // A Dir describes a file and is returned by Stat, Fstat, and Lstat
 type Dir struct {
-	Dev		uint64;	// device number of file system holding file.
-	Ino		uint64;	// inode number.
-	Nlink		uint64;	// number of hard links.
-	Mode		uint32;	// permission and mode bits.
-	Uid		uint32;	// user id of owner.
-	Gid		uint32;	// group id of owner.
-	Rdev		uint64;	// device type for special file.
-	Size		uint64;	// length in bytes.
-	Blksize		uint64;	// size of blocks, in bytes.
-	Blocks		uint64;	// number of blocks allocated for file.
-	Atime_ns	uint64;	// access time; nanoseconds since epoch.
-	Mtime_ns	uint64;	// modified time; nanoseconds since epoch.
-	Ctime_ns	uint64;	// status change time; nanoseconds since epoch.
-	Name		string;	// name of file as presented to Open.
-	FollowedSymlink	bool;	// followed a symlink to get this information
+	Dev             uint64 // device number of file system holding file.
+	Ino             uint64 // inode number.
+	Nlink           uint64 // number of hard links.
+	Mode            uint32 // permission and mode bits.
+	Uid             uint32 // user id of owner.
+	Gid             uint32 // group id of owner.
+	Rdev            uint64 // device type for special file.
+	Size            uint64 // length in bytes.
+	Blksize         uint64 // size of blocks, in bytes.
+	Blocks          uint64 // number of blocks allocated for file.
+	Atime_ns        uint64 // access time; nanoseconds since epoch.
+	Mtime_ns        uint64 // modified time; nanoseconds since epoch.
+	Ctime_ns        uint64 // status change time; nanoseconds since epoch.
+	Name            string // name of file as presented to Open.
+	FollowedSymlink bool   // followed a symlink to get this information
 }
 
 // IsFifo reports whether the Dir describes a FIFO file.
-func (dir *Dir) IsFifo() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFIFO }
+func (dir *Dir) IsFifo() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFIFO }
 
 // IsChar reports whether the Dir describes a character special file.
-func (dir *Dir) IsChar() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFCHR }
+func (dir *Dir) IsChar() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFCHR }
 
 // IsDirectory reports whether the Dir describes a directory.
-func (dir *Dir) IsDirectory() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFDIR }
+func (dir *Dir) IsDirectory() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFDIR }
 
 // IsBlock reports whether the Dir describes a block special file.
-func (dir *Dir) IsBlock() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFBLK }
+func (dir *Dir) IsBlock() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFBLK }
 
 // IsRegular reports whether the Dir describes a regular file.
-func (dir *Dir) IsRegular() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFREG }
+func (dir *Dir) IsRegular() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFREG }
 
 // IsSymlink reports whether the Dir describes a symbolic link.
-func (dir *Dir) IsSymlink() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFLNK }
+func (dir *Dir) IsSymlink() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFLNK }
 
 // IsSocket reports whether the Dir describes a socket.
-func (dir *Dir) IsSocket() bool	{ return (dir.Mode & syscall.S_IFMT) == syscall.S_IFSOCK }
+func (dir *Dir) IsSocket() bool { return (dir.Mode & syscall.S_IFMT) == syscall.S_IFSOCK }
 
 // Permission returns the file permission bits.
-func (dir *Dir) Permission() int	{ return int(dir.Mode & 0777) }
+func (dir *Dir) Permission() int { return int(dir.Mode & 0777) }