summaryrefslogtreecommitdiff
path: root/src/pkg/json
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/json')
-rw-r--r--src/pkg/json/decode.go58
-rw-r--r--src/pkg/json/decode_test.go102
-rw-r--r--src/pkg/json/error.go4
-rw-r--r--src/pkg/json/parse.go322
-rw-r--r--src/pkg/json/struct.go114
-rw-r--r--src/pkg/json/struct_test.go146
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)
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-22 01:11:47 +0000