1 files changed, 43 insertions, 43 deletions

diff --git a/src/pkg/json/struct.go b/src/pkg/json/struct.go
index 37728d38b..11aaccee9 100644
--- a/src/pkg/json/struct.go
+++ b/src/pkg/json/struct.go
@@ -25,7 +25,7 @@ var nobuilder *structBuilder
 func isfloat(v reflect.Value) bool {
 	switch v.(type) {
 	case *reflect.FloatValue, *reflect.Float32Value, *reflect.Float64Value:
-		return true;
+		return true
 	}
 	return false;
 }
@@ -33,36 +33,36 @@ func isfloat(v reflect.Value) bool {
 func setfloat(v reflect.Value, f float64) {
 	switch v := v.(type) {
 	case *reflect.FloatValue:
-		v.Set(float(f));
+		v.Set(float(f))
 	case *reflect.Float32Value:
-		v.Set(float32(f));
+		v.Set(float32(f))
 	case *reflect.Float64Value:
-		v.Set(float64(f));
+		v.Set(float64(f))
 	}
 }
 
 func setint(v reflect.Value, i int64) {
 	switch v := v.(type) {
 	case *reflect.IntValue:
-		v.Set(int(i));
+		v.Set(int(i))
 	case *reflect.Int8Value:
-		v.Set(int8(i));
+		v.Set(int8(i))
 	case *reflect.Int16Value:
-		v.Set(int16(i));
+		v.Set(int16(i))
 	case *reflect.Int32Value:
-		v.Set(int32(i));
+		v.Set(int32(i))
 	case *reflect.Int64Value:
-		v.Set(int64(i));
+		v.Set(int64(i))
 	case *reflect.UintValue:
-		v.Set(uint(i));
+		v.Set(uint(i))
 	case *reflect.Uint8Value:
-		v.Set(uint8(i));
+		v.Set(uint8(i))
 	case *reflect.Uint16Value:
-		v.Set(uint16(i));
+		v.Set(uint16(i))
 	case *reflect.Uint32Value:
-		v.Set(uint32(i));
+		v.Set(uint32(i))
 	case *reflect.Uint64Value:
-		v.Set(uint64(i));
+		v.Set(uint64(i))
 	}
 }
 
@@ -70,46 +70,46 @@ func setint(v reflect.Value, i int64) {
 // copy a changed b.val out to the original.
 func (b *structBuilder) Flush() {
 	if b == nil {
-		return;
+		return
 	}
 	if b.map_ != nil {
-		b.map_.SetElem(b.key, b.val);
+		b.map_.SetElem(b.key, b.val)
 	}
 }
 
 func (b *structBuilder) Int64(i int64) {
 	if b == nil {
-		return;
+		return
 	}
 	v := b.val;
 	if isfloat(v) {
-		setfloat(v, float64(i));
+		setfloat(v, float64(i))
 	} else {
-		setint(v, i);
+		setint(v, i)
 	}
 }
 
 func (b *structBuilder) Uint64(i uint64) {
 	if b == nil {
-		return;
+		return
 	}
 	v := b.val;
 	if isfloat(v) {
-		setfloat(v, float64(i));
+		setfloat(v, float64(i))
 	} else {
-		setint(v, int64(i));
+		setint(v, int64(i))
 	}
 }
 
 func (b *structBuilder) Float64(f float64) {
 	if b == nil {
-		return;
+		return
 	}
 	v := b.val;
 	if isfloat(v) {
-		setfloat(v, f);
+		setfloat(v, f)
 	} else {
-		setint(v, int64(f));
+		setint(v, int64(f))
 	}
 }
 
@@ -117,60 +117,60 @@ func (b *structBuilder) Null()	{}
 
 func (b *structBuilder) String(s string) {
 	if b == nil {
-		return;
+		return
 	}
 	if v, ok := b.val.(*reflect.StringValue); ok {
-		v.Set(s);
+		v.Set(s)
 	}
 }
 
 func (b *structBuilder) Bool(tf bool) {
 	if b == nil {
-		return;
+		return
 	}
 	if v, ok := b.val.(*reflect.BoolValue); ok {
-		v.Set(tf);
+		v.Set(tf)
 	}
 }
 
 func (b *structBuilder) Array() {
 	if b == nil {
-		return;
+		return
 	}
 	if v, ok := b.val.(*reflect.SliceValue); ok {
 		if v.IsNil() {
-			v.Set(reflect.MakeSlice(v.Type().(*reflect.SliceType), 0, 8));
+			v.Set(reflect.MakeSlice(v.Type().(*reflect.SliceType), 0, 8))
 		}
 	}
 }
 
 func (b *structBuilder) Elem(i int) Builder {
 	if b == nil || i < 0 {
-		return nobuilder;
+		return nobuilder
 	}
 	switch v := b.val.(type) {
 	case *reflect.ArrayValue:
 		if i < v.Len() {
-			return &structBuilder{val: v.Elem(i)};
+			return &structBuilder{val: v.Elem(i)}
 		}
 	case *reflect.SliceValue:
 		if i > v.Cap() {
 			n := v.Cap();
 			if n < 8 {
-				n = 8;
+				n = 8
 			}
 			for n <= i {
-				n *= 2;
+				n *= 2
 			}
 			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);
+			v.SetLen(i+1)
 		}
 		if i < v.Len() {
-			return &structBuilder{val: v.Elem(i)};
+			return &structBuilder{val: v.Elem(i)}
 		}
 	}
 	return nobuilder;
@@ -178,7 +178,7 @@ func (b *structBuilder) Elem(i int) Builder {
 
 func (b *structBuilder) Map() {
 	if b == nil {
-		return;
+		return
 	}
 	if v, ok := b.val.(*reflect.PtrValue); ok && v.IsNil() {
 		if v.IsNil() {
@@ -189,13 +189,13 @@ func (b *structBuilder) Map() {
 		b.val = v.Elem();
 	}
 	if v, ok := b.val.(*reflect.MapValue); ok && v.IsNil() {
-		v.Set(reflect.MakeMap(v.Type().(*reflect.MapType)));
+		v.Set(reflect.MakeMap(v.Type().(*reflect.MapType)))
 	}
 }
 
 func (b *structBuilder) Key(k string) Builder {
 	if b == nil {
-		return nobuilder;
+		return nobuilder
 	}
 	switch v := reflect.Indirect(b.val).(type) {
 	case *reflect.StructValue:
@@ -204,13 +204,13 @@ func (b *structBuilder) Key(k string) Builder {
 		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)};
+				return &structBuilder{val: v.Field(i)}
 			}
 		}
 	case *reflect.MapValue:
 		t := v.Type().(*reflect.MapType);
 		if t.Key() != reflect.Typeof(k) {
-			break;
+			break
 		}
 		key := reflect.NewValue(k);
 		elem := v.Elem(key);
@@ -286,7 +286,7 @@ func Unmarshal(s string, val interface{}) (ok bool, errtok string) {
 	b := &structBuilder{val: reflect.NewValue(val)};
 	ok, _, errtok = Parse(s, b);
 	if !ok {
-		return false, errtok;
+		return false, errtok
 	}
 	return true, "";
 }