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) }