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

3rd set of files.

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

1 files changed, 224 insertions, 224 deletions

diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go
index a3294ac50..c7f314369 100644
--- a/src/pkg/gob/decode.go
+++ b/src/pkg/gob/decode.go
@@ -8,35 +8,35 @@ package gob
 // the allocations in this file that use unsafe.Pointer.
 
 import (
-	"bytes";
-	"io";
-	"math";
-	"os";
-	"reflect";
-	"runtime";
-	"unsafe";
+	"bytes"
+	"io"
+	"math"
+	"os"
+	"reflect"
+	"runtime"
+	"unsafe"
 )
 
 var (
-	errBadUint	= os.ErrorString("gob: encoded unsigned integer out of range");
-	errBadType	= os.ErrorString("gob: unknown type id or corrupted data");
-	errRange	= os.ErrorString("gob: internal error: field numbers out of bounds");
-	errNotStruct	= os.ErrorString("gob: TODO: can only handle structs");
+	errBadUint   = os.ErrorString("gob: encoded unsigned integer out of range")
+	errBadType   = os.ErrorString("gob: unknown type id or corrupted data")
+	errRange     = os.ErrorString("gob: internal error: field numbers out of bounds")
+	errNotStruct = os.ErrorString("gob: TODO: can only handle structs")
 )
 
 // The global execution state of an instance of the decoder.
 type decodeState struct {
-	b		*bytes.Buffer;
-	err		os.Error;
-	fieldnum	int;	// the last field number read.
-	buf		[]byte;
+	b        *bytes.Buffer
+	err      os.Error
+	fieldnum int // the last field number read.
+	buf      []byte
 }
 
 func newDecodeState(b *bytes.Buffer) *decodeState {
-	d := new(decodeState);
-	d.b = b;
-	d.buf = make([]byte, uint64Size);
-	return d;
+	d := new(decodeState)
+	d.b = b
+	d.buf = make([]byte, uint64Size)
+	return d
 }
 
 func overflow(name string) os.ErrorString {
@@ -46,33 +46,33 @@ func overflow(name string) os.ErrorString {
 // decodeUintReader reads an encoded unsigned integer from an io.Reader.
 // Used only by the Decoder to read the message length.
 func decodeUintReader(r io.Reader, buf []byte) (x uint64, err os.Error) {
-	_, err = r.Read(buf[0:1]);
+	_, err = r.Read(buf[0:1])
 	if err != nil {
 		return
 	}
-	b := buf[0];
+	b := buf[0]
 	if b <= 0x7f {
 		return uint64(b), nil
 	}
-	nb := -int(int8(b));
+	nb := -int(int8(b))
 	if nb > uint64Size {
-		err = errBadUint;
-		return;
+		err = errBadUint
+		return
 	}
-	var n int;
-	n, err = io.ReadFull(r, buf[0:nb]);
+	var n int
+	n, err = io.ReadFull(r, buf[0:nb])
 	if err != nil {
 		if err == os.EOF {
 			err = io.ErrUnexpectedEOF
 		}
-		return;
+		return
 	}
 	// Could check that the high byte is zero but it's not worth it.
 	for i := 0; i < n; i++ {
-		x <<= 8;
-		x |= uint64(buf[i]);
+		x <<= 8
+		x |= uint64(buf[i])
 	}
-	return;
+	return
 }
 
 // decodeUint reads an encoded unsigned integer from state.r.
@@ -82,50 +82,50 @@ func decodeUint(state *decodeState) (x uint64) {
 	if state.err != nil {
 		return
 	}
-	var b uint8;
-	b, state.err = state.b.ReadByte();
-	if b <= 0x7f {	// includes state.err != nil
+	var b uint8
+	b, state.err = state.b.ReadByte()
+	if b <= 0x7f { // includes state.err != nil
 		return uint64(b)
 	}
-	nb := -int(int8(b));
+	nb := -int(int8(b))
 	if nb > uint64Size {
-		state.err = errBadUint;
-		return;
+		state.err = errBadUint
+		return
 	}
-	var n int;
-	n, state.err = state.b.Read(state.buf[0:nb]);
+	var n int
+	n, state.err = state.b.Read(state.buf[0:nb])
 	// Don't need to check error; it's safe to loop regardless.
 	// Could check that the high byte is zero but it's not worth it.
 	for i := 0; i < n; i++ {
-		x <<= 8;
-		x |= uint64(state.buf[i]);
+		x <<= 8
+		x |= uint64(state.buf[i])
 	}
-	return x;
+	return x
 }
 
 // decodeInt reads an encoded signed integer from state.r.
 // Sets state.err.  If state.err is already non-nil, it does nothing.
 // Does not check for overflow.
 func decodeInt(state *decodeState) int64 {
-	x := decodeUint(state);
+	x := decodeUint(state)
 	if state.err != nil {
 		return 0
 	}
 	if x&1 != 0 {
 		return ^int64(x >> 1)
 	}
-	return int64(x >> 1);
+	return int64(x >> 1)
 }
 
 type decOp func(i *decInstr, state *decodeState, p unsafe.Pointer)
 
 // The 'instructions' of the decoding machine
 type decInstr struct {
-	op	decOp;
-	field	int;		// field number of the wire type
-	indir	int;		// how many pointer indirections to reach the value in the struct
-	offset	uintptr;	// offset in the structure of the field to encode
-	ovfl	os.ErrorString;	// error message for overflow/underflow (for arrays, of the elements)
+	op     decOp
+	field  int            // field number of the wire type
+	indir  int            // how many pointer indirections to reach the value in the struct
+	offset uintptr        // offset in the structure of the field to encode
+	ovfl   os.ErrorString // error message for overflow/underflow (for arrays, of the elements)
 }
 
 // Since the encoder writes no zeros, if we arrive at a decoder we have
@@ -142,9 +142,9 @@ func decIndirect(p unsafe.Pointer, indir int) unsafe.Pointer {
 			// Allocation required
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(unsafe.Pointer))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	return p;
+	return p
 }
 
 func ignoreUint(i *decInstr, state *decodeState, p unsafe.Pointer) {
@@ -156,9 +156,9 @@ func decBool(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(bool))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	*(*bool)(p) = decodeInt(state) != 0;
+	*(*bool)(p) = decodeInt(state) != 0
 }
 
 func decInt8(i *decInstr, state *decodeState, p unsafe.Pointer) {
@@ -166,9 +166,9 @@ func decInt8(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int8))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := decodeInt(state);
+	v := decodeInt(state)
 	if v < math.MinInt8 || math.MaxInt8 < v {
 		state.err = i.ovfl
 	} else {
@@ -181,9 +181,9 @@ func decUint8(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint8))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := decodeUint(state);
+	v := decodeUint(state)
 	if math.MaxUint8 < v {
 		state.err = i.ovfl
 	} else {
@@ -196,9 +196,9 @@ func decInt16(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int16))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := decodeInt(state);
+	v := decodeInt(state)
 	if v < math.MinInt16 || math.MaxInt16 < v {
 		state.err = i.ovfl
 	} else {
@@ -211,9 +211,9 @@ func decUint16(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint16))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := decodeUint(state);
+	v := decodeUint(state)
 	if math.MaxUint16 < v {
 		state.err = i.ovfl
 	} else {
@@ -226,9 +226,9 @@ func decInt32(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int32))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := decodeInt(state);
+	v := decodeInt(state)
 	if v < math.MinInt32 || math.MaxInt32 < v {
 		state.err = i.ovfl
 	} else {
@@ -241,9 +241,9 @@ func decUint32(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint32))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := decodeUint(state);
+	v := decodeUint(state)
 	if math.MaxUint32 < v {
 		state.err = i.ovfl
 	} else {
@@ -256,9 +256,9 @@ func decInt64(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(int64))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	*(*int64)(p) = int64(decodeInt(state));
+	*(*int64)(p) = int64(decodeInt(state))
 }
 
 func decUint64(i *decInstr, state *decodeState, p unsafe.Pointer) {
@@ -266,9 +266,9 @@ func decUint64(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(uint64))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	*(*uint64)(p) = uint64(decodeUint(state));
+	*(*uint64)(p) = uint64(decodeUint(state))
 }
 
 // Floating-point numbers are transmitted as uint64s holding the bits
@@ -277,13 +277,13 @@ func decUint64(i *decInstr, state *decodeState, p unsafe.Pointer) {
 // (for example) transmit more compactly.  This routine does the
 // unswizzling.
 func floatFromBits(u uint64) float64 {
-	var v uint64;
+	var v uint64
 	for i := 0; i < 8; i++ {
-		v <<= 8;
-		v |= u & 0xFF;
-		u >>= 8;
+		v <<= 8
+		v |= u & 0xFF
+		u >>= 8
 	}
-	return math.Float64frombits(v);
+	return math.Float64frombits(v)
 }
 
 func decFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
@@ -291,14 +291,14 @@ func decFloat32(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(float32))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	v := floatFromBits(decodeUint(state));
-	av := v;
+	v := floatFromBits(decodeUint(state))
+	av := v
 	if av < 0 {
 		av = -av
 	}
-	if math.MaxFloat32 < av {	// underflow is OK
+	if math.MaxFloat32 < av { // underflow is OK
 		state.err = i.ovfl
 	} else {
 		*(*float32)(p) = float32(v)
@@ -310,9 +310,9 @@ func decFloat64(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new(float64))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	*(*float64)(p) = floatFromBits(uint64(decodeUint(state)));
+	*(*float64)(p) = floatFromBits(uint64(decodeUint(state)))
 }
 
 // uint8 arrays are encoded as an unsigned count followed by the raw bytes.
@@ -321,11 +321,11 @@ func decUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new([]uint8))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	b := make([]uint8, decodeUint(state));
-	state.b.Read(b);
-	*(*[]uint8)(p) = b;
+	b := make([]uint8, decodeUint(state))
+	state.b.Read(b)
+	*(*[]uint8)(p) = b
 }
 
 // Strings are encoded as an unsigned count followed by the raw bytes.
@@ -334,16 +334,16 @@ func decString(i *decInstr, state *decodeState, p unsafe.Pointer) {
 		if *(*unsafe.Pointer)(p) == nil {
 			*(*unsafe.Pointer)(p) = unsafe.Pointer(new([]byte))
 		}
-		p = *(*unsafe.Pointer)(p);
+		p = *(*unsafe.Pointer)(p)
 	}
-	b := make([]byte, decodeUint(state));
-	state.b.Read(b);
-	*(*string)(p) = string(b);
+	b := make([]byte, decodeUint(state))
+	state.b.Read(b)
+	*(*string)(p) = string(b)
 }
 
 func ignoreUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
-	b := make([]byte, decodeUint(state));
-	state.b.Read(b);
+	b := make([]byte, decodeUint(state))
+	state.b.Read(b)
 }
 
 // Execution engine
@@ -351,13 +351,13 @@ func ignoreUint8Array(i *decInstr, state *decodeState, p unsafe.Pointer) {
 // The encoder engine is an array of instructions indexed by field number of the incoming
 // decoder.  It is executed with random access according to field number.
 type decEngine struct {
-	instr		[]decInstr;
-	numInstr	int;	// the number of active instructions
+	instr    []decInstr
+	numInstr int // the number of active instructions
 }
 
 func decodeStruct(engine *decEngine, rtyp *reflect.StructType, b *bytes.Buffer, p uintptr, indir int) os.Error {
 	if indir > 0 {
-		up := unsafe.Pointer(p);
+		up := unsafe.Pointer(p)
 		if indir > 1 {
 			up = decIndirect(up, indir)
 		}
@@ -365,120 +365,120 @@ func decodeStruct(engine *decEngine, rtyp *reflect.StructType, b *bytes.Buffer,
 			// Allocate object.
 			*(*unsafe.Pointer)(up) = unsafe.New((*runtime.StructType)(unsafe.Pointer(rtyp)))
 		}
-		p = *(*uintptr)(up);
+		p = *(*uintptr)(up)
 	}
-	state := newDecodeState(b);
-	state.fieldnum = -1;
-	basep := p;
+	state := newDecodeState(b)
+	state.fieldnum = -1
+	basep := p
 	for state.err == nil {
-		delta := int(decodeUint(state));
+		delta := int(decodeUint(state))
 		if delta < 0 {
-			state.err = os.ErrorString("gob decode: corrupted data: negative delta");
-			break;
+			state.err = os.ErrorString("gob decode: corrupted data: negative delta")
+			break
 		}
-		if state.err != nil || delta == 0 {	// struct terminator is zero delta fieldnum
+		if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
 			break
 		}
-		fieldnum := state.fieldnum + delta;
+		fieldnum := state.fieldnum + delta
 		if fieldnum >= len(engine.instr) {
-			state.err = errRange;
-			break;
+			state.err = errRange
+			break
 		}
-		instr := &engine.instr[fieldnum];
-		p := unsafe.Pointer(basep + instr.offset);
+		instr := &engine.instr[fieldnum]
+		p := unsafe.Pointer(basep + instr.offset)
 		if instr.indir > 1 {
 			p = decIndirect(p, instr.indir)
 		}
-		instr.op(instr, state, p);
-		state.fieldnum = fieldnum;
+		instr.op(instr, state, p)
+		state.fieldnum = fieldnum
 	}
-	return state.err;
+	return state.err
 }
 
 func ignoreStruct(engine *decEngine, b *bytes.Buffer) os.Error {
-	state := newDecodeState(b);
-	state.fieldnum = -1;
+	state := newDecodeState(b)
+	state.fieldnum = -1
 	for state.err == nil {
-		delta := int(decodeUint(state));
+		delta := int(decodeUint(state))
 		if delta < 0 {
-			state.err = os.ErrorString("gob ignore decode: corrupted data: negative delta");
-			break;
+			state.err = os.ErrorString("gob ignore decode: corrupted data: negative delta")
+			break
 		}
-		if state.err != nil || delta == 0 {	// struct terminator is zero delta fieldnum
+		if state.err != nil || delta == 0 { // struct terminator is zero delta fieldnum
 			break
 		}
-		fieldnum := state.fieldnum + delta;
+		fieldnum := state.fieldnum + delta
 		if fieldnum >= len(engine.instr) {
-			state.err = errRange;
-			break;
+			state.err = errRange
+			break
 		}
-		instr := &engine.instr[fieldnum];
-		instr.op(instr, state, unsafe.Pointer(nil));
-		state.fieldnum = fieldnum;
+		instr := &engine.instr[fieldnum]
+		instr.op(instr, state, unsafe.Pointer(nil))
+		state.fieldnum = fieldnum
 	}
-	return state.err;
+	return state.err
 }
 
 func decodeArrayHelper(state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, elemIndir int, ovfl os.ErrorString) os.Error {
-	instr := &decInstr{elemOp, 0, elemIndir, 0, ovfl};
+	instr := &decInstr{elemOp, 0, elemIndir, 0, ovfl}
 	for i := 0; i < length && state.err == nil; i++ {
-		up := unsafe.Pointer(p);
+		up := unsafe.Pointer(p)
 		if elemIndir > 1 {
 			up = decIndirect(up, elemIndir)
 		}
-		elemOp(instr, state, up);
-		p += uintptr(elemWid);
+		elemOp(instr, state, up)
+		p += uintptr(elemWid)
 	}
-	return state.err;
+	return state.err
 }
 
 func decodeArray(atyp *reflect.ArrayType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, length, indir, elemIndir int, ovfl os.ErrorString) os.Error {
 	if indir > 0 {
-		up := unsafe.Pointer(p);
+		up := unsafe.Pointer(p)
 		if *(*unsafe.Pointer)(up) == nil {
 			// Allocate object.
 			*(*unsafe.Pointer)(up) = unsafe.New(atyp)
 		}
-		p = *(*uintptr)(up);
+		p = *(*uintptr)(up)
 	}
 	if n := decodeUint(state); n != uint64(length) {
 		return os.ErrorString("gob: length mismatch in decodeArray")
 	}
-	return decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl);
+	return decodeArrayHelper(state, p, elemOp, elemWid, length, elemIndir, ovfl)
 }
 
 func ignoreArrayHelper(state *decodeState, elemOp decOp, length int) os.Error {
-	instr := &decInstr{elemOp, 0, 0, 0, os.ErrorString("no error")};
+	instr := &decInstr{elemOp, 0, 0, 0, os.ErrorString("no error")}
 	for i := 0; i < length && state.err == nil; i++ {
 		elemOp(instr, state, nil)
 	}
-	return state.err;
+	return state.err
 }
 
 func ignoreArray(state *decodeState, elemOp decOp, length int) os.Error {
 	if n := decodeUint(state); n != uint64(length) {
 		return os.ErrorString("gob: length mismatch in ignoreArray")
 	}
-	return ignoreArrayHelper(state, elemOp, length);
+	return ignoreArrayHelper(state, elemOp, length)
 }
 
 func decodeSlice(atyp *reflect.SliceType, state *decodeState, p uintptr, elemOp decOp, elemWid uintptr, indir, elemIndir int, ovfl os.ErrorString) os.Error {
-	n := int(uintptr(decodeUint(state)));
+	n := int(uintptr(decodeUint(state)))
 	if indir > 0 {
-		up := unsafe.Pointer(p);
+		up := unsafe.Pointer(p)
 		if *(*unsafe.Pointer)(up) == nil {
 			// Allocate the slice header.
 			*(*unsafe.Pointer)(up) = unsafe.Pointer(new([]unsafe.Pointer))
 		}
-		p = *(*uintptr)(up);
+		p = *(*uintptr)(up)
 	}
 	// Allocate storage for the slice elements, that is, the underlying array.
 	// Always write a header at p.
-	hdrp := (*reflect.SliceHeader)(unsafe.Pointer(p));
-	hdrp.Data = uintptr(unsafe.NewArray(atyp.Elem(), n));
-	hdrp.Len = n;
-	hdrp.Cap = n;
-	return decodeArrayHelper(state, hdrp.Data, elemOp, elemWid, n, elemIndir, ovfl);
+	hdrp := (*reflect.SliceHeader)(unsafe.Pointer(p))
+	hdrp.Data = uintptr(unsafe.NewArray(atyp.Elem(), n))
+	hdrp.Len = n
+	hdrp.Cap = n
+	return decodeArrayHelper(state, hdrp.Data, elemOp, elemWid, n, elemIndir, ovfl)
 }
 
 func ignoreSlice(state *decodeState, elemOp decOp) os.Error {
@@ -512,104 +512,104 @@ var decIgnoreOpMap = map[typeId]decOp{
 // Return the decoding op for the base type under rt and
 // the indirection count to reach it.
 func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string) (decOp, int, os.Error) {
-	typ, indir := indirect(rt);
-	op, ok := decOpMap[reflect.Typeof(typ)];
+	typ, indir := indirect(rt)
+	op, ok := decOpMap[reflect.Typeof(typ)]
 	if !ok {
 		// Special cases
 		switch t := typ.(type) {
 		case *reflect.SliceType:
-			name = "element of " + name;
+			name = "element of " + name
 			if _, ok := t.Elem().(*reflect.Uint8Type); ok {
-				op = decUint8Array;
-				break;
+				op = decUint8Array
+				break
 			}
-			var elemId typeId;
+			var elemId typeId
 			if tt, ok := builtinIdToType[wireId]; ok {
 				elemId = tt.(*sliceType).Elem
 			} else {
 				elemId = dec.wireType[wireId].slice.Elem
 			}
-			elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name);
+			elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name)
 			if err != nil {
 				return nil, 0, err
 			}
-			ovfl := overflow(name);
+			ovfl := overflow(name)
 			op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
 				state.err = decodeSlice(t, state, uintptr(p), elemOp, t.Elem().Size(), i.indir, elemIndir, ovfl)
-			};
+			}
 
 		case *reflect.ArrayType:
-			name = "element of " + name;
-			elemId := wireId.gobType().(*arrayType).Elem;
-			elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name);
+			name = "element of " + name
+			elemId := wireId.gobType().(*arrayType).Elem
+			elemOp, elemIndir, err := dec.decOpFor(elemId, t.Elem(), name)
 			if err != nil {
 				return nil, 0, err
 			}
-			ovfl := overflow(name);
+			ovfl := overflow(name)
 			op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
 				state.err = decodeArray(t, state, uintptr(p), elemOp, t.Elem().Size(), t.Len(), i.indir, elemIndir, ovfl)
-			};
+			}
 
 		case *reflect.StructType:
 			// Generate a closure that calls out to the engine for the nested type.
-			enginePtr, err := dec.getDecEnginePtr(wireId, typ);
+			enginePtr, err := dec.getDecEnginePtr(wireId, typ)
 			if err != nil {
 				return nil, 0, err
 			}
 			op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
 				// indirect through enginePtr to delay evaluation for recursive structs
 				state.err = decodeStruct(*enginePtr, t, state.b, uintptr(p), i.indir)
-			};
+			}
 		}
 	}
 	if op == nil {
 		return nil, 0, os.ErrorString("gob: decode can't handle type " + rt.String())
 	}
-	return op, indir, nil;
+	return op, indir, nil
 }
 
 // Return the decoding op for a field that has no destination.
 func (dec *Decoder) decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
-	op, ok := decIgnoreOpMap[wireId];
+	op, ok := decIgnoreOpMap[wireId]
 	if !ok {
 		// Special cases
 		switch t := wireId.gobType().(type) {
 		case *sliceType:
-			elemId := wireId.gobType().(*sliceType).Elem;
-			elemOp, err := dec.decIgnoreOpFor(elemId);
+			elemId := wireId.gobType().(*sliceType).Elem
+			elemOp, err := dec.decIgnoreOpFor(elemId)
 			if err != nil {
 				return nil, err
 			}
 			op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
 				state.err = ignoreSlice(state, elemOp)
-			};
+			}
 
 		case *arrayType:
-			elemId := wireId.gobType().(*arrayType).Elem;
-			elemOp, err := dec.decIgnoreOpFor(elemId);
+			elemId := wireId.gobType().(*arrayType).Elem
+			elemOp, err := dec.decIgnoreOpFor(elemId)
 			if err != nil {
 				return nil, err
 			}
 			op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
 				state.err = ignoreArray(state, elemOp, t.Len)
-			};
+			}
 
 		case *structType:
 			// Generate a closure that calls out to the engine for the nested type.
-			enginePtr, err := dec.getIgnoreEnginePtr(wireId);
+			enginePtr, err := dec.getIgnoreEnginePtr(wireId)
 			if err != nil {
 				return nil, err
 			}
 			op = func(i *decInstr, state *decodeState, p unsafe.Pointer) {
 				// indirect through enginePtr to delay evaluation for recursive structs
 				state.err = ignoreStruct(*enginePtr, state.b)
-			};
+			}
 		}
 	}
 	if op == nil {
 		return nil, os.ErrorString("ignore can't handle type " + wireId.string())
 	}
-	return op, nil;
+	return op, nil
 }
 
 // Are these two gob Types compatible?
@@ -618,10 +618,10 @@ func (dec *Decoder) decIgnoreOpFor(wireId typeId) (decOp, os.Error) {
 func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId) bool {
 	for {
 		if pt, ok := fr.(*reflect.PtrType); ok {
-			fr = pt.Elem();
-			continue;
+			fr = pt.Elem()
+			continue
 		}
-		break;
+		break
 	}
 	switch t := fr.(type) {
 	default:
@@ -660,89 +660,89 @@ func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId) bool {
 	case *reflect.StringType:
 		return fw == tString
 	case *reflect.ArrayType:
-		aw, ok := fw.gobType().(*arrayType);
-		return ok && t.Len() == aw.Len && dec.compatibleType(t.Elem(), aw.Elem);
+		aw, ok := fw.gobType().(*arrayType)
+		return ok && t.Len() == aw.Len && dec.compatibleType(t.Elem(), aw.Elem)
 	case *reflect.SliceType:
 		// Is it an array of bytes?
-		et := t.Elem();
+		et := t.Elem()
 		if _, ok := et.(*reflect.Uint8Type); ok {
 			return fw == tBytes
 		}
 		// Extract and compare element types.
-		var sw *sliceType;
+		var sw *sliceType
 		if tt, ok := builtinIdToType[fw]; ok {
 			sw = tt.(*sliceType)
 		} else {
 			sw = dec.wireType[fw].slice
 		}
-		elem, _ := indirect(t.Elem());
-		return sw != nil && dec.compatibleType(elem, sw.Elem);
+		elem, _ := indirect(t.Elem())
+		return sw != nil && dec.compatibleType(elem, sw.Elem)
 	case *reflect.StructType:
 		return true
 	}
-	return true;
+	return true
 }
 
 func (dec *Decoder) compileDec(remoteId typeId, rt reflect.Type) (engine *decEngine, err os.Error) {
-	srt, ok1 := rt.(*reflect.StructType);
-	var wireStruct *structType;
+	srt, ok1 := rt.(*reflect.StructType)
+	var wireStruct *structType
 	// Builtin types can come from global pool; the rest must be defined by the decoder
 	if t, ok := builtinIdToType[remoteId]; ok {
 		wireStruct = t.(*structType)
 	} else {
-		w, ok2 := dec.wireType[remoteId];
+		w, ok2 := dec.wireType[remoteId]
 		if !ok1 || !ok2 {
 			return nil, errNotStruct
 		}
-		wireStruct = w.strct;
+		wireStruct = w.strct
 	}
-	engine = new(decEngine);
-	engine.instr = make([]decInstr, len(wireStruct.field));
+	engine = new(decEngine)
+	engine.instr = make([]decInstr, len(wireStruct.field))
 	// Loop over the fields of the wire type.
 	for fieldnum := 0; fieldnum < len(wireStruct.field); fieldnum++ {
-		wireField := wireStruct.field[fieldnum];
+		wireField := wireStruct.field[fieldnum]
 		// Find the field of the local type with the same name.
-		localField, present := srt.FieldByName(wireField.name);
-		ovfl := overflow(wireField.name);
+		localField, present := srt.FieldByName(wireField.name)
+		ovfl := overflow(wireField.name)
 		// TODO(r): anonymous names
 		if !present {
-			op, err := dec.decIgnoreOpFor(wireField.id);
+			op, err := dec.decIgnoreOpFor(wireField.id)
 			if err != nil {
 				return nil, err
 			}
-			engine.instr[fieldnum] = decInstr{op, fieldnum, 0, 0, ovfl};
-			continue;
+			engine.instr[fieldnum] = decInstr{op, fieldnum, 0, 0, ovfl}
+			continue
 		}
 		if !dec.compatibleType(localField.Type, wireField.id) {
-			details := " (" + wireField.id.string() + " incompatible with " + localField.Type.String() + ") in type " + remoteId.Name();
-			return nil, os.ErrorString("gob: wrong type for field " + wireField.name + details);
+			details := " (" + wireField.id.string() + " incompatible with " + localField.Type.String() + ") in type " + remoteId.Name()
+			return nil, os.ErrorString("gob: wrong type for field " + wireField.name + details)
 		}
-		op, indir, err := dec.decOpFor(wireField.id, localField.Type, localField.Name);
+		op, indir, err := dec.decOpFor(wireField.id, localField.Type, localField.Name)
 		if err != nil {
 			return nil, err
 		}
-		engine.instr[fieldnum] = decInstr{op, fieldnum, indir, uintptr(localField.Offset), ovfl};
-		engine.numInstr++;
+		engine.instr[fieldnum] = decInstr{op, fieldnum, indir, uintptr(localField.Offset), ovfl}
+		engine.numInstr++
 	}
-	return;
+	return
 }
 
 func (dec *Decoder) getDecEnginePtr(remoteId typeId, rt reflect.Type) (enginePtr **decEngine, err os.Error) {
-	decoderMap, ok := dec.decoderCache[rt];
+	decoderMap, ok := dec.decoderCache[rt]
 	if !ok {
-		decoderMap = make(map[typeId]**decEngine);
-		dec.decoderCache[rt] = decoderMap;
+		decoderMap = make(map[typeId]**decEngine)
+		dec.decoderCache[rt] = decoderMap
 	}
 	if enginePtr, ok = decoderMap[remoteId]; !ok {
 		// To handle recursive types, mark this engine as underway before compiling.
-		enginePtr = new(*decEngine);
-		decoderMap[remoteId] = enginePtr;
-		*enginePtr, err = dec.compileDec(remoteId, rt);
+		enginePtr = new(*decEngine)
+		decoderMap[remoteId] = enginePtr
+		*enginePtr, err = dec.compileDec(remoteId, rt)
 		if err != nil {
 			decoderMap[remoteId] = nil, false
 		}
 	}
-	return;
+	return
 }
 
 // When ignoring data, in effect we compile it into this type
@@ -751,42 +751,42 @@ type emptyStruct struct{}
 var emptyStructType = reflect.Typeof(emptyStruct{})
 
 func (dec *Decoder) getIgnoreEnginePtr(wireId typeId) (enginePtr **decEngine, err os.Error) {
-	var ok bool;
+	var ok bool
 	if enginePtr, ok = dec.ignorerCache[wireId]; !ok {
 		// To handle recursive types, mark this engine as underway before compiling.
-		enginePtr = new(*decEngine);
-		dec.ignorerCache[wireId] = enginePtr;
-		*enginePtr, err = dec.compileDec(wireId, emptyStructType);
+		enginePtr = new(*decEngine)
+		dec.ignorerCache[wireId] = enginePtr
+		*enginePtr, err = dec.compileDec(wireId, emptyStructType)
 		if err != nil {
 			dec.ignorerCache[wireId] = nil, false
 		}
 	}
-	return;
+	return
 }
 
 func (dec *Decoder) decode(wireId typeId, e interface{}) os.Error {
 	// Dereference down to the underlying struct type.
-	rt, indir := indirect(reflect.Typeof(e));
-	st, ok := rt.(*reflect.StructType);
+	rt, indir := indirect(reflect.Typeof(e))
+	st, ok := rt.(*reflect.StructType)
 	if !ok {
 		return os.ErrorString("gob: decode can't handle " + rt.String())
 	}
-	enginePtr, err := dec.getDecEnginePtr(wireId, rt);
+	enginePtr, err := dec.getDecEnginePtr(wireId, rt)
 	if err != nil {
 		return err
 	}
-	engine := *enginePtr;
+	engine := *enginePtr
 	if engine.numInstr == 0 && st.NumField() > 0 && len(wireId.gobType().(*structType).field) > 0 {
-		name := rt.Name();
-		return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name);
+		name := rt.Name()
+		return os.ErrorString("gob: type mismatch: no fields matched compiling decoder for " + name)
 	}
-	return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir);
+	return decodeStruct(engine, st, dec.state.b, uintptr(reflect.NewValue(e).Addr()), indir)
 }
 
 func init() {
 	// We assume that the size of float is sufficient to tell us whether it is
 	// equivalent to float32 or to float64.   This is very unlikely to be wrong.
-	var op decOp;
+	var op decOp
 	switch unsafe.Sizeof(float(0)) {
 	case unsafe.Sizeof(float32(0)):
 		op = decFloat32
@@ -795,22 +795,22 @@ func init() {
 	default:
 		panic("gob: unknown size of float", unsafe.Sizeof(float(0)))
 	}
-	decOpMap[valueKind(float(0))] = op;
+	decOpMap[valueKind(float(0))] = op
 
 	// A similar assumption about int and uint.  Also assume int and uint have the same size.
-	var uop decOp;
+	var uop decOp
 	switch unsafe.Sizeof(int(0)) {
 	case unsafe.Sizeof(int32(0)):
-		op = decInt32;
-		uop = decUint32;
+		op = decInt32
+		uop = decUint32
 	case unsafe.Sizeof(int64(0)):
-		op = decInt64;
-		uop = decUint64;
+		op = decInt64
+		uop = decUint64
 	default:
 		panic("gob: unknown size of int/uint", unsafe.Sizeof(int(0)))
 	}
-	decOpMap[valueKind(int(0))] = op;
-	decOpMap[valueKind(uint(0))] = uop;
+	decOpMap[valueKind(int(0))] = op
+	decOpMap[valueKind(uint(0))] = uop
 
 	// Finally uintptr
 	switch unsafe.Sizeof(uintptr(0)) {
@@ -821,5 +821,5 @@ func init() {
 	default:
 		panic("gob: unknown size of uintptr", unsafe.Sizeof(uintptr(0)))
 	}
-	decOpMap[valueKind(uintptr(0))] = uop;
+	decOpMap[valueKind(uintptr(0))] = uop
 }