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

6 files changed, 373 insertions, 373 deletions

diff --git a/src/pkg/json/decode.go b/src/pkg/json/decode.go
index 386ca0016..c2dd93eca 100644
--- a/src/pkg/json/decode.go
+++ b/src/pkg/json/decode.go
@@ -8,8 +8,8 @@
 package json
 
 import (
-	"container/vector";
-	"os";
+	"container/vector"
+	"os"
 )
 
 // Decode a JSON string
@@ -23,75 +23,75 @@ import (
 // If Decode encounters a syntax error, it returns with err set to an
 // instance of ParseError.  See ParseError documentation for details.
 func Decode(s string) (data interface{}, err os.Error) {
-	jb := newDecoder(nil, nil);
-	ok, errPos, errTok := Parse(s, jb);
+	jb := newDecoder(nil, nil)
+	ok, errPos, errTok := Parse(s, jb)
 	if ok {
 		data = jb.Data()
 	} else {
 		err = &ParseError{Index: errPos, Token: errTok}
 	}
-	return;
+	return
 }
 
 type decoder struct {
 	// A value being constructed.
-	value	interface{};
+	value interface{}
 	// Container entity to flush into.  Can be either vector.Vector or
 	// map[string]interface{}.
-	container	interface{};
+	container interface{}
 	// The index into the container interface.  Either int or string.
-	index	interface{};
+	index interface{}
 }
 
 func newDecoder(container interface{}, key interface{}) *decoder {
 	return &decoder{container: container, index: key}
 }
 
-func (j *decoder) Int64(i int64)	{ j.value = float64(i) }
+func (j *decoder) Int64(i int64) { j.value = float64(i) }
 
-func (j *decoder) Uint64(i uint64)	{ j.value = float64(i) }
+func (j *decoder) Uint64(i uint64) { j.value = float64(i) }
 
-func (j *decoder) Float64(f float64)	{ j.value = float64(f) }
+func (j *decoder) Float64(f float64) { j.value = float64(f) }
 
-func (j *decoder) String(s string)	{ j.value = s }
+func (j *decoder) String(s string) { j.value = s }
 
-func (j *decoder) Bool(b bool)	{ j.value = b }
+func (j *decoder) Bool(b bool) { j.value = b }
 
-func (j *decoder) Null()	{ j.value = nil }
+func (j *decoder) Null() { j.value = nil }
 
-func (j *decoder) Array()	{ j.value = new(vector.Vector) }
+func (j *decoder) Array() { j.value = new(vector.Vector) }
 
-func (j *decoder) Map()	{ j.value = make(map[string]interface{}) }
+func (j *decoder) Map() { j.value = make(map[string]interface{}) }
 
 func (j *decoder) Elem(i int) Builder {
-	v, ok := j.value.(*vector.Vector);
+	v, ok := j.value.(*vector.Vector)
 	if !ok {
-		v = new(vector.Vector);
-		j.value = v;
+		v = new(vector.Vector)
+		j.value = v
 	}
 	if v.Len() <= i {
 		v.Resize(i+1, (i+1)*2)
 	}
-	return newDecoder(v, i);
+	return newDecoder(v, i)
 }
 
 func (j *decoder) Key(s string) Builder {
-	m, ok := j.value.(map[string]interface{});
+	m, ok := j.value.(map[string]interface{})
 	if !ok {
-		m = make(map[string]interface{});
-		j.value = m;
+		m = make(map[string]interface{})
+		j.value = m
 	}
-	return newDecoder(m, s);
+	return newDecoder(m, s)
 }
 
 func (j *decoder) Flush() {
 	switch c := j.container.(type) {
 	case *vector.Vector:
-		index := j.index.(int);
-		c.Set(index, j.Data());
+		index := j.index.(int)
+		c.Set(index, j.Data())
 	case map[string]interface{}:
-		index := j.index.(string);
-		c[index] = j.Data();
+		index := j.index.(string)
+		c[index] = j.Data()
 	}
 }
 
@@ -101,5 +101,5 @@ func (j *decoder) Data() interface{} {
 	case *vector.Vector:
 		return v.Data()
 	}
-	return j.value;
+	return j.value
 }
diff --git a/src/pkg/json/decode_test.go b/src/pkg/json/decode_test.go
index 1b429b0ee..b712d6558 100644
--- a/src/pkg/json/decode_test.go
+++ b/src/pkg/json/decode_test.go
@@ -5,73 +5,73 @@
 package json
 
 import (
-	"container/vector";
-	"reflect";
-	"testing";
+	"container/vector"
+	"reflect"
+	"testing"
 )
 
 func TestDecodeInt64(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Int64(-15);
-	assertResult(t, nb.Data(), float64(-15));
+	nb := newDecoder(nil, nil)
+	nb.Int64(-15)
+	assertResult(t, nb.Data(), float64(-15))
 }
 
 func TestDecodeUint64(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Uint64(15);
-	assertResult(t, nb.Data(), float64(15));
+	nb := newDecoder(nil, nil)
+	nb.Uint64(15)
+	assertResult(t, nb.Data(), float64(15))
 }
 
 func TestDecodeFloat64(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Float64(3.14159);
-	assertResult(t, nb.Data(), float64(3.14159));
+	nb := newDecoder(nil, nil)
+	nb.Float64(3.14159)
+	assertResult(t, nb.Data(), float64(3.14159))
 }
 
 func TestDecodeString(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.String("Some string");
-	assertResult(t, nb.Data(), "Some string");
+	nb := newDecoder(nil, nil)
+	nb.String("Some string")
+	assertResult(t, nb.Data(), "Some string")
 }
 
 func TestDecodeBool(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Bool(true);
-	assertResult(t, nb.Data(), true);
+	nb := newDecoder(nil, nil)
+	nb.Bool(true)
+	assertResult(t, nb.Data(), true)
 }
 
 func TestDecodeNull(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Null();
-	assertResult(t, nb.Data(), nil);
+	nb := newDecoder(nil, nil)
+	nb.Null()
+	assertResult(t, nb.Data(), nil)
 }
 
 func TestDecodeEmptyArray(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Array();
-	assertResult(t, nb.Data(), []interface{}{});
+	nb := newDecoder(nil, nil)
+	nb.Array()
+	assertResult(t, nb.Data(), []interface{}{})
 }
 
 func TestDecodeEmptyMap(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Map();
-	assertResult(t, nb.Data(), map[string]interface{}{});
+	nb := newDecoder(nil, nil)
+	nb.Map()
+	assertResult(t, nb.Data(), map[string]interface{}{})
 }
 
 func TestDecodeFlushElem(t *testing.T) {
-	testVec := new(vector.Vector).Resize(2, 2);
-	nb := newDecoder(testVec, 1);
-	nb.Float64(3.14159);
-	nb.Flush();
-	assertResult(t, testVec.Data(), []interface{}{nil, float64(3.14159)});
+	testVec := new(vector.Vector).Resize(2, 2)
+	nb := newDecoder(testVec, 1)
+	nb.Float64(3.14159)
+	nb.Flush()
+	assertResult(t, testVec.Data(), []interface{}{nil, float64(3.14159)})
 }
 
 func TestDecodeFlushKey(t *testing.T) {
-	testMap := make(map[string]interface{});
-	nb := newDecoder(testMap, "key");
-	nb.Float64(3.14159);
-	nb.Flush();
-	assertResult(t, testMap, map[string]interface{}{"key": float64(3.14159)});
+	testMap := make(map[string]interface{})
+	nb := newDecoder(testMap, "key")
+	nb.Float64(3.14159)
+	nb.Flush()
+	assertResult(t, testMap, map[string]interface{}{"key": float64(3.14159)})
 }
 
 // Elem() and Key() are hard to test in isolation because all they do
@@ -80,21 +80,21 @@ func TestDecodeFlushKey(t *testing.T) {
 // Array(), String(), and Flush().
 
 func TestDecodeElem(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Array();
-	var b Builder = nb.Elem(0);
-	b.String("0");
-	b.Flush();
-	assertResult(t, nb.Data(), []interface{}{"0"});
+	nb := newDecoder(nil, nil)
+	nb.Array()
+	var b Builder = nb.Elem(0)
+	b.String("0")
+	b.Flush()
+	assertResult(t, nb.Data(), []interface{}{"0"})
 }
 
 func TestDecodeKey(t *testing.T) {
-	nb := newDecoder(nil, nil);
-	nb.Map();
-	var b Builder = nb.Key("a");
-	b.String("0");
-	b.Flush();
-	assertResult(t, nb.Data(), map[string]interface{}{"a": "0"});
+	nb := newDecoder(nil, nil)
+	nb.Map()
+	var b Builder = nb.Key("a")
+	b.String("0")
+	b.Flush()
+	assertResult(t, nb.Data(), map[string]interface{}{"a": "0"})
 }
 
 func assertResult(t *testing.T, results, expected interface{}) {
@@ -104,8 +104,8 @@ func assertResult(t *testing.T, results, expected interface{}) {
 }
 
 type decodeTest struct {
-	s	string;
-	r	interface{};
+	s string
+	r interface{}
 }
 
 var tests = []decodeTest{
diff --git a/src/pkg/json/error.go b/src/pkg/json/error.go
index aa5b962ae..c5f31b02d 100644
--- a/src/pkg/json/error.go
+++ b/src/pkg/json/error.go
@@ -9,8 +9,8 @@ import "fmt"
 // ParseError aggregates information about a JSON parse error.  It is
 // compatible with the os.Error interface.
 type ParseError struct {
-	Index	int;	// A byte index in JSON string where the error occurred
-	Token	string;	// An offending token
+	Index int    // A byte index in JSON string where the error occurred
+	Token string // An offending token
 }
 
 // Produce a string representation of this ParseError.
diff --git a/src/pkg/json/parse.go b/src/pkg/json/parse.go
index f9c472977..f7eb0a61b 100644
--- a/src/pkg/json/parse.go
+++ b/src/pkg/json/parse.go
@@ -11,9 +11,9 @@
 package json
 
 import (
-	"bytes";
-	"strconv";
-	"utf8";
+	"bytes"
+	"strconv"
+	"utf8"
 )
 
 // Strings
@@ -23,12 +23,12 @@ import (
 //   Have also seen \' and embedded newlines.
 
 func _UnHex(p string, r, l int) (v int, ok bool) {
-	v = 0;
+	v = 0
 	for i := r; i < l; i++ {
 		if i >= len(p) {
 			return 0, false
 		}
-		v *= 16;
+		v *= 16
 		switch {
 		case '0' <= p[i] && p[i] <= '9':
 			v += int(p[i] - '0')
@@ -40,15 +40,15 @@ func _UnHex(p string, r, l int) (v int, ok bool) {
 			return 0, false
 		}
 	}
-	return v, true;
+	return v, true
 }
 
 func _ToHex(b []byte, rune int) {
-	const hexDigits = "0123456789abcdef";
-	b[0] = hexDigits[rune>>12&0xf];
-	b[1] = hexDigits[rune>>8&0xf];
-	b[2] = hexDigits[rune>>4&0xf];
-	b[3] = hexDigits[rune&0xf];
+	const hexDigits = "0123456789abcdef"
+	b[0] = hexDigits[rune>>12&0xf]
+	b[1] = hexDigits[rune>>8&0xf]
+	b[2] = hexDigits[rune>>4&0xf]
+	b[3] = hexDigits[rune&0xf]
 }
 
 // Unquote unquotes the JSON-quoted string s,
@@ -58,12 +58,12 @@ func Unquote(s string) (t string, ok bool) {
 	if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
 		return
 	}
-	b := make([]byte, len(s));
-	w := 0;
+	b := make([]byte, len(s))
+	w := 0
 	for r := 1; r < len(s)-1; {
 		switch {
 		case s[r] == '\\':
-			r++;
+			r++
 			if r >= len(s)-1 {
 				return
 			}
@@ -71,147 +71,147 @@ func Unquote(s string) (t string, ok bool) {
 			default:
 				return
 			case '"', '\\', '/', '\'':
-				b[w] = s[r];
-				r++;
-				w++;
+				b[w] = s[r]
+				r++
+				w++
 			case 'b':
-				b[w] = '\b';
-				r++;
-				w++;
+				b[w] = '\b'
+				r++
+				w++
 			case 'f':
-				b[w] = '\f';
-				r++;
-				w++;
+				b[w] = '\f'
+				r++
+				w++
 			case 'n':
-				b[w] = '\n';
-				r++;
-				w++;
+				b[w] = '\n'
+				r++
+				w++
 			case 'r':
-				b[w] = '\r';
-				r++;
-				w++;
+				b[w] = '\r'
+				r++
+				w++
 			case 't':
-				b[w] = '\t';
-				r++;
-				w++;
+				b[w] = '\t'
+				r++
+				w++
 			case 'u':
-				r++;
-				rune, ok := _UnHex(s, r, r+4);
+				r++
+				rune, ok := _UnHex(s, r, r+4)
 				if !ok {
 					return
 				}
-				r += 4;
-				w += utf8.EncodeRune(rune, b[w:]);
+				r += 4
+				w += utf8.EncodeRune(rune, b[w:])
 			}
 		// Control characters are invalid, but we've seen raw \n.
 		case s[r] < ' ' && s[r] != '\n':
 			if s[r] == '\n' {
-				b[w] = '\n';
-				r++;
-				w++;
-				break;
+				b[w] = '\n'
+				r++
+				w++
+				break
 			}
-			return;
+			return
 		// ASCII
 		case s[r] < utf8.RuneSelf:
-			b[w] = s[r];
-			r++;
-			w++;
+			b[w] = s[r]
+			r++
+			w++
 		// Coerce to well-formed UTF-8.
 		default:
-			rune, size := utf8.DecodeRuneInString(s[r:]);
-			r += size;
-			w += utf8.EncodeRune(rune, b[w:]);
+			rune, size := utf8.DecodeRuneInString(s[r:])
+			r += size
+			w += utf8.EncodeRune(rune, b[w:])
 		}
 	}
-	return string(b[0:w]), true;
+	return string(b[0:w]), true
 }
 
 // Quote quotes the raw string s using JSON syntax,
 // so that Unquote(Quote(s)) = s, true.
 func Quote(s string) string {
-	chr := make([]byte, 6);
-	chr0 := chr[0:1];
-	b := new(bytes.Buffer);
-	chr[0] = '"';
-	b.Write(chr0);
+	chr := make([]byte, 6)
+	chr0 := chr[0:1]
+	b := new(bytes.Buffer)
+	chr[0] = '"'
+	b.Write(chr0)
 
 	for _, rune := range s {
 		switch {
 		case rune == '"' || rune == '\\':
-			chr[0] = '\\';
-			chr[1] = byte(rune);
-			b.Write(chr[0:2]);
+			chr[0] = '\\'
+			chr[1] = byte(rune)
+			b.Write(chr[0:2])
 
 		case rune == '\b':
-			chr[0] = '\\';
-			chr[1] = 'b';
-			b.Write(chr[0:2]);
+			chr[0] = '\\'
+			chr[1] = 'b'
+			b.Write(chr[0:2])
 
 		case rune == '\f':
-			chr[0] = '\\';
-			chr[1] = 'f';
-			b.Write(chr[0:2]);
+			chr[0] = '\\'
+			chr[1] = 'f'
+			b.Write(chr[0:2])
 
 		case rune == '\n':
-			chr[0] = '\\';
-			chr[1] = 'n';
-			b.Write(chr[0:2]);
+			chr[0] = '\\'
+			chr[1] = 'n'
+			b.Write(chr[0:2])
 
 		case rune == '\r':
-			chr[0] = '\\';
-			chr[1] = 'r';
-			b.Write(chr[0:2]);
+			chr[0] = '\\'
+			chr[1] = 'r'
+			b.Write(chr[0:2])
 
 		case rune == '\t':
-			chr[0] = '\\';
-			chr[1] = 't';
-			b.Write(chr[0:2]);
+			chr[0] = '\\'
+			chr[1] = 't'
+			b.Write(chr[0:2])
 
 		case 0x20 <= rune && rune < utf8.RuneSelf:
-			chr[0] = byte(rune);
-			b.Write(chr0);
+			chr[0] = byte(rune)
+			b.Write(chr0)
 
 		default:
-			chr[0] = '\\';
-			chr[1] = 'u';
-			_ToHex(chr[2:6], rune);
-			b.Write(chr);
+			chr[0] = '\\'
+			chr[1] = 'u'
+			_ToHex(chr[2:6], rune)
+			b.Write(chr)
 		}
 	}
-	chr[0] = '"';
-	b.Write(chr0);
-	return b.String();
+	chr[0] = '"'
+	b.Write(chr0)
+	return b.String()
 }
 
 
 // _Lexer
 
 type _Lexer struct {
-	s	string;
-	i	int;
-	kind	int;
-	token	string;
+	s     string
+	i     int
+	kind  int
+	token string
 }
 
 func punct(c byte) bool {
 	return c == '"' || c == '[' || c == ']' || c == ':' || c == '{' || c == '}' || c == ','
 }
 
-func white(c byte) bool	{ return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' }
+func white(c byte) bool { return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' }
 
 func skipwhite(p string, i int) int {
 	for i < len(p) && white(p[i]) {
 		i++
 	}
-	return i;
+	return i
 }
 
 func skiptoken(p string, i int) int {
 	for i < len(p) && !punct(p[i]) && !white(p[i]) {
 		i++
 	}
-	return i;
+	return i
 }
 
 func skipstring(p string, i int) int {
@@ -223,50 +223,50 @@ func skipstring(p string, i int) int {
 	if i >= len(p) {
 		return i
 	}
-	return i + 1;
+	return i + 1
 }
 
 func (t *_Lexer) Next() {
-	i, s := t.i, t.s;
-	i = skipwhite(s, i);
+	i, s := t.i, t.s
+	i = skipwhite(s, i)
 	if i >= len(s) {
-		t.kind = 0;
-		t.token = "";
-		t.i = len(s);
-		return;
+		t.kind = 0
+		t.token = ""
+		t.i = len(s)
+		return
 	}
 
-	c := s[i];
+	c := s[i]
 	switch {
 	case c == '-' || '0' <= c && c <= '9':
-		j := skiptoken(s, i);
-		t.kind = '1';
-		t.token = s[i:j];
-		i = j;
+		j := skiptoken(s, i)
+		t.kind = '1'
+		t.token = s[i:j]
+		i = j
 
 	case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
-		j := skiptoken(s, i);
-		t.kind = 'a';
-		t.token = s[i:j];
-		i = j;
+		j := skiptoken(s, i)
+		t.kind = 'a'
+		t.token = s[i:j]
+		i = j
 
 	case c == '"':
-		j := skipstring(s, i);
-		t.kind = '"';
-		t.token = s[i:j];
-		i = j;
+		j := skipstring(s, i)
+		t.kind = '"'
+		t.token = s[i:j]
+		i = j
 
 	case c == '[', c == ']', c == ':', c == '{', c == '}', c == ',':
-		t.kind = int(c);
-		t.token = s[i : i+1];
-		i++;
+		t.kind = int(c)
+		t.token = s[i : i+1]
+		i++
 
 	default:
-		t.kind = '?';
-		t.token = s[i : i+1];
+		t.kind = '?'
+		t.token = s[i : i+1]
 	}
 
-	t.i = i;
+	t.i = i
 }
 
 
@@ -297,25 +297,25 @@ type _Value interface{}
 // eventual representation returned by the parser.
 type Builder interface {
 	// Set value
-	Int64(i int64);
-	Uint64(i uint64);
-	Float64(f float64);
-	String(s string);
-	Bool(b bool);
-	Null();
-	Array();
-	Map();
+	Int64(i int64)
+	Uint64(i uint64)
+	Float64(f float64)
+	String(s string)
+	Bool(b bool)
+	Null()
+	Array()
+	Map()
 
 	// Create sub-Builders
-	Elem(i int) Builder;
-	Key(s string) Builder;
+	Elem(i int) Builder
+	Key(s string) Builder
 
 	// Flush changes to parent Builder if necessary.
-	Flush();
+	Flush()
 }
 
 func parse(lex *_Lexer, build Builder) bool {
-	ok := false;
+	ok := false
 Switch:
 	switch lex.kind {
 	case 0:
@@ -323,93 +323,93 @@ Switch:
 	case '1':
 		// If the number is exactly an integer, use that.
 		if i, err := strconv.Atoi64(lex.token); err == nil {
-			build.Int64(i);
-			ok = true;
+			build.Int64(i)
+			ok = true
 		} else if i, err := strconv.Atoui64(lex.token); err == nil {
-			build.Uint64(i);
-			ok = true;
+			build.Uint64(i)
+			ok = true
 		} else
 		// Fall back to floating point.
 		if f, err := strconv.Atof64(lex.token); err == nil {
-			build.Float64(f);
-			ok = true;
+			build.Float64(f)
+			ok = true
 		}
 
 	case 'a':
 		switch lex.token {
 		case "true":
-			build.Bool(true);
-			ok = true;
+			build.Bool(true)
+			ok = true
 		case "false":
-			build.Bool(false);
-			ok = true;
+			build.Bool(false)
+			ok = true
 		case "null":
-			build.Null();
-			ok = true;
+			build.Null()
+			ok = true
 		}
 
 	case '"':
 		if str, ok1 := Unquote(lex.token); ok1 {
-			build.String(str);
-			ok = true;
+			build.String(str)
+			ok = true
 		}
 
 	case '[':
 		// array
-		build.Array();
-		lex.Next();
-		n := 0;
+		build.Array()
+		lex.Next()
+		n := 0
 		for lex.kind != ']' {
 			if n > 0 {
 				if lex.kind != ',' {
 					break Switch
 				}
-				lex.Next();
+				lex.Next()
 			}
 			if !parse(lex, build.Elem(n)) {
 				break Switch
 			}
-			n++;
+			n++
 		}
-		ok = true;
+		ok = true
 
 	case '{':
 		// map
-		lex.Next();
-		build.Map();
-		n := 0;
+		lex.Next()
+		build.Map()
+		n := 0
 		for lex.kind != '}' {
 			if n > 0 {
 				if lex.kind != ',' {
 					break Switch
 				}
-				lex.Next();
+				lex.Next()
 			}
 			if lex.kind != '"' {
 				break Switch
 			}
-			key, ok := Unquote(lex.token);
+			key, ok := Unquote(lex.token)
 			if !ok {
 				break Switch
 			}
-			lex.Next();
+			lex.Next()
 			if lex.kind != ':' {
 				break Switch
 			}
-			lex.Next();
+			lex.Next()
 			if !parse(lex, build.Key(key)) {
 				break Switch
 			}
-			n++;
+			n++
 		}
-		ok = true;
+		ok = true
 	}
 
 	if ok {
 		lex.Next()
 	}
-	build.Flush();
-	return ok;
+	build.Flush()
+	return ok
 }
 
 // Parse parses the JSON syntax string s and makes calls to
@@ -419,13 +419,13 @@ Switch:
 // to the byte index in s where a syntax error occurred,
 // and errtok set to the offending token.
 func Parse(s string, builder Builder) (ok bool, errindx int, errtok string) {
-	lex := new(_Lexer);
-	lex.s = s;
-	lex.Next();
+	lex := new(_Lexer)
+	lex.s = s
+	lex.Next()
 	if parse(lex, builder) {
-		if lex.kind == 0 {	// EOF
+		if lex.kind == 0 { // EOF
 			return true, 0, ""
 		}
 	}
-	return false, lex.i, lex.token;
+	return false, lex.i, lex.token
 }
diff --git a/src/pkg/json/struct.go b/src/pkg/json/struct.go
index d34939cbd..4f2a1782c 100644
--- a/src/pkg/json/struct.go
+++ b/src/pkg/json/struct.go
@@ -8,19 +8,19 @@
 package json
 
 import (
-	"fmt";
-	"io";
-	"os";
-	"reflect";
-	"strings";
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"strings"
 )
 
 type structBuilder struct {
-	val	reflect.Value;
+	val reflect.Value
 
 	// if map_ != nil, write val to map_[key] on each change
-	map_	*reflect.MapValue;
-	key	reflect.Value;
+	map_ *reflect.MapValue
+	key  reflect.Value
 }
 
 var nobuilder *structBuilder
@@ -30,7 +30,7 @@ func isfloat(v reflect.Value) bool {
 	case *reflect.FloatValue, *reflect.Float32Value, *reflect.Float64Value:
 		return true
 	}
-	return false;
+	return false
 }
 
 func setfloat(v reflect.Value, f float64) {
@@ -84,7 +84,7 @@ func (b *structBuilder) Int64(i int64) {
 	if b == nil {
 		return
 	}
-	v := b.val;
+	v := b.val
 	if isfloat(v) {
 		setfloat(v, float64(i))
 	} else {
@@ -96,7 +96,7 @@ func (b *structBuilder) Uint64(i uint64) {
 	if b == nil {
 		return
 	}
-	v := b.val;
+	v := b.val
 	if isfloat(v) {
 		setfloat(v, float64(i))
 	} else {
@@ -108,7 +108,7 @@ func (b *structBuilder) Float64(f float64) {
 	if b == nil {
 		return
 	}
-	v := b.val;
+	v := b.val
 	if isfloat(v) {
 		setfloat(v, f)
 	} else {
@@ -116,7 +116,7 @@ func (b *structBuilder) Float64(f float64) {
 	}
 }
 
-func (b *structBuilder) Null()	{}
+func (b *structBuilder) Null() {}
 
 func (b *structBuilder) String(s string) {
 	if b == nil {
@@ -158,16 +158,16 @@ func (b *structBuilder) Elem(i int) Builder {
 		}
 	case *reflect.SliceValue:
 		if i >= v.Cap() {
-			n := v.Cap();
+			n := v.Cap()
 			if n < 8 {
 				n = 8
 			}
 			for n <= i {
 				n *= 2
 			}
-			nv := reflect.MakeSlice(v.Type().(*reflect.SliceType), v.Len(), n);
-			reflect.ArrayCopy(nv, v);
-			v.Set(nv);
+			nv := reflect.MakeSlice(v.Type().(*reflect.SliceType), v.Len(), n)
+			reflect.ArrayCopy(nv, v)
+			v.Set(nv)
 		}
 		if v.Len() <= i && i < v.Cap() {
 			v.SetLen(i + 1)
@@ -176,7 +176,7 @@ func (b *structBuilder) Elem(i int) Builder {
 			return &structBuilder{val: v.Elem(i)}
 		}
 	}
-	return nobuilder;
+	return nobuilder
 }
 
 func (b *structBuilder) Map() {
@@ -185,11 +185,11 @@ func (b *structBuilder) Map() {
 	}
 	if v, ok := b.val.(*reflect.PtrValue); ok && v.IsNil() {
 		if v.IsNil() {
-			v.PointTo(reflect.MakeZero(v.Type().(*reflect.PtrType).Elem()));
-			b.Flush();
+			v.PointTo(reflect.MakeZero(v.Type().(*reflect.PtrType).Elem()))
+			b.Flush()
 		}
-		b.map_ = nil;
-		b.val = v.Elem();
+		b.map_ = nil
+		b.val = v.Elem()
 	}
 	if v, ok := b.val.(*reflect.MapValue); ok && v.IsNil() {
 		v.Set(reflect.MakeMap(v.Type().(*reflect.MapType)))
@@ -202,28 +202,28 @@ func (b *structBuilder) Key(k string) Builder {
 	}
 	switch v := reflect.Indirect(b.val).(type) {
 	case *reflect.StructValue:
-		t := v.Type().(*reflect.StructType);
+		t := v.Type().(*reflect.StructType)
 		// Case-insensitive field lookup.
-		k = strings.ToLower(k);
+		k = strings.ToLower(k)
 		for i := 0; i < t.NumField(); i++ {
 			if strings.ToLower(t.Field(i).Name) == k {
 				return &structBuilder{val: v.Field(i)}
 			}
 		}
 	case *reflect.MapValue:
-		t := v.Type().(*reflect.MapType);
+		t := v.Type().(*reflect.MapType)
 		if t.Key() != reflect.Typeof(k) {
 			break
 		}
-		key := reflect.NewValue(k);
-		elem := v.Elem(key);
+		key := reflect.NewValue(k)
+		elem := v.Elem(key)
 		if elem == nil {
-			v.SetElem(key, reflect.MakeZero(t.Elem()));
-			elem = v.Elem(key);
+			v.SetElem(key, reflect.MakeZero(t.Elem()))
+			elem = v.Elem(key)
 		}
-		return &structBuilder{val: elem, map_: v, key: key};
+		return &structBuilder{val: elem, map_: v, key: key}
 	}
-	return nobuilder;
+	return nobuilder
 }
 
 // Unmarshal parses the JSON syntax string s and fills in
@@ -289,8 +289,8 @@ func (b *structBuilder) Key(k string) Builder {
 // On a syntax error, it returns with ok set to false and errtok
 // set to the offending token.
 func Unmarshal(s string, val interface{}) (ok bool, errtok string) {
-	v := reflect.NewValue(val);
-	var b *structBuilder;
+	v := reflect.NewValue(val)
+	var b *structBuilder
 
 	// If val is a pointer to a slice, we append to the slice.
 	if ptr, ok := v.(*reflect.PtrValue); ok {
@@ -303,22 +303,22 @@ func Unmarshal(s string, val interface{}) (ok bool, errtok string) {
 		b = &structBuilder{val: v}
 	}
 
-	ok, _, errtok = Parse(s, b);
+	ok, _, errtok = Parse(s, b)
 	if !ok {
 		return false, errtok
 	}
-	return true, "";
+	return true, ""
 }
 
 type MarshalError struct {
-	T reflect.Type;
+	T reflect.Type
 }
 
 func (e *MarshalError) String() string {
 	return "json cannot encode value of type " + e.T.String()
 }
 func writeArrayOrSlice(w io.Writer, val reflect.ArrayOrSliceValue) os.Error {
-	fmt.Fprint(w, "[");
+	fmt.Fprint(w, "[")
 
 	for i := 0; i < val.Len(); i++ {
 		if err := writeValue(w, val.Elem(i)); err != nil {
@@ -330,20 +330,20 @@ func writeArrayOrSlice(w io.Writer, val reflect.ArrayOrSliceValue) os.Error {
 		}
 	}
 
-	fmt.Fprint(w, "]");
-	return nil;
+	fmt.Fprint(w, "]")
+	return nil
 }
 
 func writeMap(w io.Writer, val *reflect.MapValue) os.Error {
-	key := val.Type().(*reflect.MapType).Key();
+	key := val.Type().(*reflect.MapType).Key()
 	if _, ok := key.(*reflect.StringType); !ok {
 		return &MarshalError{val.Type()}
 	}
 
-	keys := val.Keys();
-	fmt.Fprint(w, "{");
+	keys := val.Keys()
+	fmt.Fprint(w, "{")
 	for i := 0; i < len(keys); i++ {
-		fmt.Fprintf(w, "%q:", keys[i].(*reflect.StringValue).Get());
+		fmt.Fprintf(w, "%q:", keys[i].(*reflect.StringValue).Get())
 
 		if err := writeValue(w, val.Elem(keys[i])); err != nil {
 			return err
@@ -354,32 +354,32 @@ func writeMap(w io.Writer, val *reflect.MapValue) os.Error {
 		}
 	}
 
-	fmt.Fprint(w, "}");
-	return nil;
+	fmt.Fprint(w, "}")
+	return nil
 }
 
 func writeStruct(w io.Writer, val *reflect.StructValue) os.Error {
-	fmt.Fprint(w, "{");
+	fmt.Fprint(w, "{")
 
-	typ := val.Type().(*reflect.StructType);
+	typ := val.Type().(*reflect.StructType)
 
 	for i := 0; i < val.NumField(); i++ {
-		fieldValue := val.Field(i);
-		fmt.Fprintf(w, "%q:", typ.Field(i).Name);
-		writeValue(w, fieldValue);
+		fieldValue := val.Field(i)
+		fmt.Fprintf(w, "%q:", typ.Field(i).Name)
+		writeValue(w, fieldValue)
 		if i < val.NumField()-1 {
 			fmt.Fprint(w, ",")
 		}
 	}
 
-	fmt.Fprint(w, "}");
-	return nil;
+	fmt.Fprint(w, "}")
+	return nil
 }
 
 func writeValue(w io.Writer, val reflect.Value) (err os.Error) {
 	if val == nil {
-		fmt.Fprint(w, "null");
-		return;
+		fmt.Fprint(w, "null")
+		return
 	}
 
 	switch v := val.(type) {
@@ -404,10 +404,10 @@ func writeValue(w io.Writer, val reflect.Value) (err os.Error) {
 			err = &MarshalError{val.Type()}
 		}
 	default:
-		value := val.(reflect.Value);
-		fmt.Fprint(w, value.Interface());
+		value := val.(reflect.Value)
+		fmt.Fprint(w, value.Interface())
 	}
-	return;
+	return
 }
 
 func Marshal(w io.Writer, val interface{}) os.Error {
diff --git a/src/pkg/json/struct_test.go b/src/pkg/json/struct_test.go
index 1511bc45c..9a928f7d0 100644
--- a/src/pkg/json/struct_test.go
+++ b/src/pkg/json/struct_test.go
@@ -5,34 +5,34 @@
 package json
 
 import (
-	"bytes";
-	"reflect";
-	"strconv";
-	"testing";
+	"bytes"
+	"reflect"
+	"strconv"
+	"testing"
 )
 
 type myStruct struct {
-	T		bool;
-	F		bool;
-	S		string;
-	I8		int8;
-	I16		int16;
-	I32		int32;
-	I64		int64;
-	U8		uint8;
-	U16		uint16;
-	U32		uint32;
-	U64		uint64;
-	I		int;
-	U		uint;
-	Fl		float;
-	Fl32		float32;
-	Fl64		float64;
-	A		[]string;
-	My		*myStruct;
-	Map		map[string][]int;
-	MapStruct	map[string]myStruct;
-	MapPtrStruct	map[string]*myStruct;
+	T            bool
+	F            bool
+	S            string
+	I8           int8
+	I16          int16
+	I32          int32
+	I64          int64
+	U8           uint8
+	U16          uint16
+	U32          uint32
+	U64          uint64
+	I            int
+	U            uint
+	Fl           float
+	Fl32         float32
+	Fl64         float64
+	A            []string
+	My           *myStruct
+	Map          map[string][]int
+	MapStruct    map[string]myStruct
+	MapPtrStruct map[string]*myStruct
 }
 
 const encoded = `{"t":true,"f":false,"s":"abc","i8":1,"i16":2,"i32":3,"i64":4,` +
@@ -69,58 +69,58 @@ func check(t *testing.T, ok bool, name string, v interface{}) {
 const whiteSpaceEncoded = " \t{\n\"s\"\r:\"string\"\v}"
 
 func TestUnmarshalWhitespace(t *testing.T) {
-	var m myStruct;
-	ok, errtok := Unmarshal(whiteSpaceEncoded, &m);
+	var m myStruct
+	ok, errtok := Unmarshal(whiteSpaceEncoded, &m)
 	if !ok {
 		t.Fatalf("Unmarshal failed near %s", errtok)
 	}
-	check(t, m.S == "string", "string", m.S);
+	check(t, m.S == "string", "string", m.S)
 }
 
 func TestUnmarshal(t *testing.T) {
-	var m myStruct;
-	m.F = true;
-	ok, errtok := Unmarshal(encoded, &m);
+	var m myStruct
+	m.F = true
+	ok, errtok := Unmarshal(encoded, &m)
 	if !ok {
 		t.Fatalf("Unmarshal failed near %s", errtok)
 	}
-	check(t, m.T == true, "t", m.T);
-	check(t, m.F == false, "f", m.F);
-	check(t, m.S == "abc", "s", m.S);
-	check(t, m.I8 == 1, "i8", m.I8);
-	check(t, m.I16 == 2, "i16", m.I16);
-	check(t, m.I32 == 3, "i32", m.I32);
-	check(t, m.I64 == 4, "i64", m.I64);
-	check(t, m.U8 == 5, "u8", m.U8);
-	check(t, m.U16 == 6, "u16", m.U16);
-	check(t, m.U32 == 7, "u32", m.U32);
-	check(t, m.U64 == 8, "u64", m.U64);
-	check(t, m.I == -9, "i", m.I);
-	check(t, m.U == 10, "u", m.U);
-	check(t, m.Fl == 11.5, "fl", m.Fl);
-	check(t, m.Fl32 == 12.25, "fl32", m.Fl32);
-	check(t, m.Fl64 == 13.75, "fl64", m.Fl64);
-	check(t, m.A != nil, "a", m.A);
+	check(t, m.T == true, "t", m.T)
+	check(t, m.F == false, "f", m.F)
+	check(t, m.S == "abc", "s", m.S)
+	check(t, m.I8 == 1, "i8", m.I8)
+	check(t, m.I16 == 2, "i16", m.I16)
+	check(t, m.I32 == 3, "i32", m.I32)
+	check(t, m.I64 == 4, "i64", m.I64)
+	check(t, m.U8 == 5, "u8", m.U8)
+	check(t, m.U16 == 6, "u16", m.U16)
+	check(t, m.U32 == 7, "u32", m.U32)
+	check(t, m.U64 == 8, "u64", m.U64)
+	check(t, m.I == -9, "i", m.I)
+	check(t, m.U == 10, "u", m.U)
+	check(t, m.Fl == 11.5, "fl", m.Fl)
+	check(t, m.Fl32 == 12.25, "fl32", m.Fl32)
+	check(t, m.Fl64 == 13.75, "fl64", m.Fl64)
+	check(t, m.A != nil, "a", m.A)
 	if m.A != nil {
-		check(t, m.A[0] == "x", "a[0]", m.A[0]);
-		check(t, m.A[1] == "y", "a[1]", m.A[1]);
-		check(t, m.A[2] == "z", "a[2]", m.A[2]);
+		check(t, m.A[0] == "x", "a[0]", m.A[0])
+		check(t, m.A[1] == "y", "a[1]", m.A[1])
+		check(t, m.A[2] == "z", "a[2]", m.A[2])
 	}
-	check(t, m.My != nil, "my", m.My);
+	check(t, m.My != nil, "my", m.My)
 	if m.My != nil {
 		check(t, m.My.S == "subguy", "my.s", m.My.S)
 	}
-	check(t, reflect.DeepEqual(m.Map, decodedMap), "map", m.Map);
-	check(t, reflect.DeepEqual(m.MapStruct, decodedMapStruct), "mapstruct", m.MapStruct);
-	check(t, reflect.DeepEqual(m.MapPtrStruct, decodedMapPtrStruct), "mapptrstruct", m.MapPtrStruct);
+	check(t, reflect.DeepEqual(m.Map, decodedMap), "map", m.Map)
+	check(t, reflect.DeepEqual(m.MapStruct, decodedMapStruct), "mapstruct", m.MapStruct)
+	check(t, reflect.DeepEqual(m.MapPtrStruct, decodedMapPtrStruct), "mapptrstruct", m.MapPtrStruct)
 }
 
 type Issue147Text struct {
-	Text string;
+	Text string
 }
 
 type Issue147 struct {
-	Test []Issue147Text;
+	Test []Issue147Text
 }
 
 const issue147Input = `{"test": [{"text":"0"},{"text":"1"},{"text":"2"},
@@ -135,8 +135,8 @@ const issue147Input = `{"test": [{"text":"0"},{"text":"1"},{"text":"2"},
 {"text":"27"},{"text":"28"},{"text":"29"}]}`
 
 func TestIssue147(t *testing.T) {
-	var timeline Issue147;
-	Unmarshal(issue147Input, &timeline);
+	var timeline Issue147
+	Unmarshal(issue147Input, &timeline)
 
 	if len(timeline.Test) != 30 {
 		t.Errorf("wrong length: got %d want 30", len(timeline.Test))
@@ -150,14 +150,14 @@ func TestIssue147(t *testing.T) {
 }
 
 type Issue114 struct {
-	Text string;
+	Text string
 }
 
 const issue114Input = `[{"text" : "0"}, {"text" : "1"}, {"text" : "2"}, {"text" : "3"}]`
 
 func TestIssue114(t *testing.T) {
-	var items []Issue114;
-	Unmarshal(issue114Input, &items);
+	var items []Issue114
+	Unmarshal(issue114Input, &items)
 
 	if len(items) != 4 {
 		t.Errorf("wrong length: got %d want 4", len(items))
@@ -171,8 +171,8 @@ func TestIssue114(t *testing.T) {
 }
 
 type marshalTest struct {
-	val	interface{};
-	out	string;
+	val interface{}
+	out string
 }
 
 var marshalTests = []marshalTest{
@@ -195,8 +195,8 @@ var marshalTests = []marshalTest{
 	marshalTest{struct{ a int }{1}, `{"a":1}`},
 	marshalTest{struct{ a interface{} }{nil}, `{"a":null}`},
 	marshalTest{struct {
-		a	int;
-		b	string;
+		a int
+		b string
 	}{1, "hello"},
 		`{"a":1,"b":"hello"}`,
 	},
@@ -205,14 +205,14 @@ var marshalTests = []marshalTest{
 
 func TestMarshal(t *testing.T) {
 	for _, tt := range marshalTests {
-		var buf bytes.Buffer;
+		var buf bytes.Buffer
 
-		err := Marshal(&buf, tt.val);
+		err := Marshal(&buf, tt.val)
 		if err != nil {
 			t.Fatalf("Marshal(%T): %s", tt.val, err)
 		}
 
-		s := buf.String();
+		s := buf.String()
 		if s != tt.out {
 			t.Errorf("Marshal(%T) = %q, want %q\n", tt.val, tt.out, s)
 		}
@@ -220,8 +220,8 @@ func TestMarshal(t *testing.T) {
 }
 
 type marshalErrorTest struct {
-	val	interface{};
-	error	string;
+	val   interface{}
+	error string
 }
 
 type MTE string
@@ -233,9 +233,9 @@ var marshalErrorTests = []marshalErrorTest{
 
 func TestMarshalError(t *testing.T) {
 	for _, tt := range marshalErrorTests {
-		var buf bytes.Buffer;
+		var buf bytes.Buffer
 
-		err := Marshal(&buf, tt.val);
+		err := Marshal(&buf, tt.val)
 
 		if err == nil {
 			t.Fatalf("Marshal(%T): no error, want error %s", tt.val, tt.error)