}
func memstats() string {
- var buf bytes.Buffer
- json.MarshalIndent(&buf, &runtime.MemStats, " ")
- s := buf.String()
- return s[0 : len(s)-1] // chop final \n
+ b, _ := json.MarshalIndent(&runtime.MemStats, "", "\t")
+ return string(b)
}
func cmdline() string {
- var buf bytes.Buffer
- json.Marshal(&buf, os.Args)
- return buf.String()
+ b, _ := json.Marshal(os.Args)
+ return string(b)
}
func init() {
// colours.String() should be '{"red":3, "blue":4}',
// though the order of red and blue could vary.
s := colours.String()
- j, err := json.Decode(s)
+ var j interface{}
+ err := json.Unmarshal([]byte(s), &j)
if err != nil {
t.Errorf("colours.String() isn't valid JSON: %v", err)
}
TARG=json
GOFILES=\
decode.go\
+ encode.go\
error.go\
indent.go\
parse.go\
scanner.go\
- struct.go\
include ../../Make.pkg
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
import (
"container/vector"
"os"
+ "reflect"
+ "runtime"
+ "strconv"
+ "strings"
+ "unicode"
+ "utf16"
+ "utf8"
)
-// Decode a JSON string
-
-// Decode parses the string s as a JSON-syntax string and returns the
-// generic JSON object representation. The object representation is a tree
-// of Go data types. The data return value may be one of float64, string,
-// bool, nil, []interface{} or map[string]interface{}. The array and map
-// elements may in turn contain any of the types listed above and so on.
+// Unmarshal parses the JSON-encoded data and stores the result
+// in the value pointed at by v.
//
-// 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)
- if ok {
- data = jb.Data()
- } else {
- err = &ParseError{Index: errPos, Token: errTok}
+// Unmarshal traverses the value v recursively.
+// If an encountered value implements the Unmarshaler interface,
+// Unmarshal calls its UnmarshalJSON method with a well-formed
+// JSON encoding.
+//
+// Otherwise, Unmarshal uses the inverse of the encodings that
+// Marshal uses, allocating maps, slices, and pointers as necessary,
+// with the following additional rules:
+//
+// To unmarshal a JSON value into a nil interface value, the
+// type stored in the interface value is one of:
+//
+// bool, for JSON booleans
+// float64, for JSON numbers
+// string, for JSON strings
+// []interface{}, for JSON arrays
+// map[string]interface{}, for JSON objects
+// nil for JSON null
+//
+// If a JSON value is not appropriate for a given target type,
+// or if a JSON number overflows the target type, Unmarshal
+// skips that field and completes the unmarshalling as best it can.
+// If no more serious errors are encountered, Unmarshal returns
+// an UnmarshalTypeError describing the earliest such error.
+//
+func Unmarshal(data []byte, v interface{}) os.Error {
+ d := new(decodeState).init(data)
+
+ // Quick check for well-formedness.
+ // Avoids filling out half a data structure
+ // before discovering a JSON syntax error.
+ err := checkValid(data, &d.scan)
+ if err != nil {
+ return err
}
- return
+
+ return d.unmarshal(v)
}
-type decoder struct {
- // A value being constructed.
- value interface{}
- // Container entity to flush into. Can be either vector.Vector or
- // map[string]interface{}.
- container interface{}
- // The index into the container interface. Either int or string.
- index interface{}
+// Unmarshaler is the interface implemented by objects
+// that can unmarshal a JSON description of themselves.
+// The input can be assumed to be a valid JSON object
+// encoding. UnmarshalJSON must copy the JSON data
+// if it wishes to retain the data after returning.
+type Unmarshaler interface {
+ UnmarshalJSON([]byte) os.Error
}
-func newDecoder(container interface{}, key interface{}) *decoder {
- return &decoder{container: container, index: key}
+
+// An UnmarshalTypeError describes a JSON value that was
+// not appropriate for a value of a specific Go type.
+type UnmarshalTypeError struct {
+ Value string // description of JSON value - "bool", "array", "number -5"
+ Type reflect.Type // type of Go value it could not be assigned to
}
-func (j *decoder) Int64(i int64) { j.value = float64(i) }
+func (e *UnmarshalTypeError) String() string {
+ return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
+}
-func (j *decoder) Uint64(i uint64) { j.value = float64(i) }
+// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+// (The argument to Unmarshal must be a non-nil pointer.)
+type InvalidUnmarshalError struct {
+ Type reflect.Type
+}
-func (j *decoder) Float64(f float64) { j.value = float64(f) }
+func (e *InvalidUnmarshalError) String() string {
+ if e.Type == nil {
+ return "json: Unmarshal(nil)"
+ }
-func (j *decoder) String(s string) { j.value = s }
+ if _, ok := e.Type.(*reflect.PtrType); !ok {
+ return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
+ }
+ return "json: Unmarshal(nil " + e.Type.String() + ")"
+}
-func (j *decoder) Bool(b bool) { j.value = b }
+func (d *decodeState) unmarshal(v interface{}) (err os.Error) {
+ defer func() {
+ if r := recover(); r != nil {
+ if _, ok := r.(runtime.Error); ok {
+ panic(r)
+ }
+ err = r.(os.Error)
+ }
+ }()
-func (j *decoder) Null() { j.value = nil }
+ rv := reflect.NewValue(v)
+ pv, ok := rv.(*reflect.PtrValue)
+ if !ok || pv.IsNil() {
+ return &InvalidUnmarshalError{reflect.Typeof(v)}
+ }
-func (j *decoder) Array() { j.value = new(vector.Vector) }
+ d.scan.reset()
+ d.value(pv.Elem())
+ return d.savedError
+}
-func (j *decoder) Map() { j.value = make(map[string]interface{}) }
+// decodeState represents the state while decoding a JSON value.
+type decodeState struct {
+ data []byte
+ off int // read offset in data
+ scan scanner
+ nextscan scanner // for calls to nextValue
+ savedError os.Error
+}
-func (j *decoder) Elem(i int) Builder {
- v, ok := j.value.(*vector.Vector)
- if !ok {
- v = new(vector.Vector)
- j.value = v
+// errPhase is used for errors that should not happen unless
+// there is a bug in the JSON decoder or something is editing
+// the data slice while the decoder executes.
+var errPhase = os.NewError("JSON decoder out of sync - data changing underfoot?")
+
+func (d *decodeState) init(data []byte) *decodeState {
+ d.data = data
+ d.off = 0
+ d.savedError = nil
+ return d
+}
+
+// error aborts the decoding by panicking with err.
+func (d *decodeState) error(err os.Error) {
+ panic(err)
+}
+
+// saveError saves the first err it is called with,
+// for reporting at the end of the unmarshal.
+func (d *decodeState) saveError(err os.Error) {
+ if d.savedError == nil {
+ d.savedError = err
+ }
+}
+
+// next cuts off and returns the next full JSON value in d.data[d.off:].
+// The next value is known to be an object or array, not a literal.
+func (d *decodeState) next() []byte {
+ c := d.data[d.off]
+ item, rest, err := nextValue(d.data[d.off:], &d.nextscan)
+ if err != nil {
+ d.error(err)
+ }
+ d.off = len(d.data) - len(rest)
+
+ // Our scanner has seen the opening brace/bracket
+ // and thinks we're still in the middle of the object.
+ // invent a closing brace/bracket to get it out.
+ if c == '{' {
+ d.scan.step(&d.scan, '}')
+ } else {
+ d.scan.step(&d.scan, ']')
}
- if v.Len() <= i {
- v.Resize(i+1, (i+1)*2)
+
+ return item
+}
+
+// scanWhile processes bytes in d.data[d.off:] until it
+// receives a scan code not equal to op.
+// It updates d.off and returns the new scan code.
+func (d *decodeState) scanWhile(op int) int {
+ var newOp int
+ for {
+ if d.off >= len(d.data) {
+ newOp = d.scan.eof()
+ d.off = len(d.data) + 1 // mark processed EOF with len+1
+ } else {
+ c := int(d.data[d.off])
+ d.off++
+ newOp = d.scan.step(&d.scan, c)
+ }
+ if newOp != op {
+ break
+ }
+ }
+ return newOp
+}
+
+// value decodes a JSON value from d.data[d.off:] into the value.
+// it updates d.off to point past the decoded value.
+func (d *decodeState) value(v reflect.Value) {
+ if v == nil {
+ _, rest, err := nextValue(d.data[d.off:], &d.nextscan)
+ if err != nil {
+ d.error(err)
+ }
+ d.off = len(d.data) - len(rest)
+
+ // d.scan thinks we're still at the beginning of the item.
+ // Feed in an empty string - the shortest, simplest value -
+ // so that it knows we got to the end of the value.
+ if d.scan.step == stateRedo {
+ panic("redo")
+ }
+ d.scan.step(&d.scan, '"')
+ d.scan.step(&d.scan, '"')
+ return
+ }
+
+ switch op := d.scanWhile(scanSkipSpace); op {
+ default:
+ d.error(errPhase)
+
+ case scanBeginArray:
+ d.array(v)
+
+ case scanBeginObject:
+ d.object(v)
+
+ case scanBeginLiteral:
+ d.literal(v)
+ }
+}
+
+// indirect walks down v allocating pointers as needed,
+// until it gets to a non-pointer.
+// if it encounters an Unmarshaler, indirect stops and returns that.
+// if wantptr is true, indirect stops at the last pointer.
+func (d *decodeState) indirect(v reflect.Value, wantptr bool) (Unmarshaler, reflect.Value) {
+ for {
+ var isUnmarshaler bool
+ if v.Type().NumMethod() > 0 {
+ // Remember that this is an unmarshaler,
+ // but wait to return it until after allocating
+ // the pointer (if necessary).
+ _, isUnmarshaler = v.Interface().(Unmarshaler)
+ }
+
+ pv, ok := v.(*reflect.PtrValue)
+ if !ok {
+ break
+ }
+ _, isptrptr := pv.Elem().(*reflect.PtrValue)
+ if !isptrptr && wantptr && !isUnmarshaler {
+ return nil, pv
+ }
+ pv.PointTo(reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem()))
+ if isUnmarshaler {
+ // Using v.Interface().(Unmarshaler)
+ // here means that we have to use a pointer
+ // as the struct field. We cannot use a value inside
+ // a pointer to a struct, because in that case
+ // v.Interface() is the value (x.f) not the pointer (&x.f).
+ // This is an unfortunate consequence of reflect.
+ // An alternative would be to look up the
+ // UnmarshalJSON method and return a FuncValue.
+ return v.Interface().(Unmarshaler), nil
+ }
+ v = pv.Elem()
}
- return newDecoder(v, i)
+ return nil, v
}
-func (j *decoder) Key(s string) Builder {
- m, ok := j.value.(map[string]interface{})
+// array consumes an array from d.data[d.off-1:], decoding into the value v.
+// the first byte of the array ('[') has been read already.
+func (d *decodeState) array(v reflect.Value) {
+ // Check for unmarshaler.
+ unmarshaler, pv := d.indirect(v, false)
+ if unmarshaler != nil {
+ d.off--
+ err := unmarshaler.UnmarshalJSON(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ v = pv
+
+ // Decoding into nil interface? Switch to non-reflect code.
+ iv, ok := v.(*reflect.InterfaceValue)
+ if ok {
+ iv.Set(reflect.NewValue(d.arrayInterface()))
+ return
+ }
+
+ // Check type of target.
+ av, ok := v.(reflect.ArrayOrSliceValue)
if !ok {
- m = make(map[string]interface{})
- j.value = m
+ d.saveError(&UnmarshalTypeError{"array", v.Type()})
+ }
+
+ sv, _ := v.(*reflect.SliceValue)
+
+ i := 0
+ for {
+ // Look ahead for ] - can only happen on first iteration.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+
+ // Back up so d.value can have the byte we just read.
+ d.off--
+ d.scan.undo(op)
+
+ // Get element of array, growing if necessary.
+ if i >= av.Cap() && sv != nil {
+ newcap := sv.Cap() + sv.Cap()/2
+ if newcap < 4 {
+ newcap = 4
+ }
+ newv := reflect.MakeSlice(sv.Type().(*reflect.SliceType), sv.Len(), newcap)
+ reflect.ArrayCopy(newv, sv)
+ sv.Set(newv)
+ }
+ if i >= av.Len() && sv != nil {
+ // Must be slice; gave up on array during i >= av.Cap().
+ sv.SetLen(i + 1)
+ }
+
+ // Decode into element.
+ if i < av.Len() {
+ d.value(av.Elem(i))
+ } else {
+ // Ran out of fixed array: skip.
+ d.value(nil)
+ }
+ i++
+
+ // Next token must be , or ].
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+ if op != scanArrayValue {
+ d.error(errPhase)
+ }
+ }
+ if i < av.Len() {
+ if sv == nil {
+ // Array. Zero the rest.
+ z := reflect.MakeZero(av.Type().(*reflect.ArrayType).Elem())
+ for ; i < av.Len(); i++ {
+ av.Elem(i).SetValue(z)
+ }
+ } else {
+ sv.SetLen(i)
+ }
+ }
+}
+
+// matchName returns true if key should be written to a field named name.
+func matchName(key, name string) bool {
+ return strings.ToLower(key) == strings.ToLower(name)
+}
+
+// object consumes an object from d.data[d.off-1:], decoding into the value v.
+// the first byte of the object ('{') has been read already.
+func (d *decodeState) object(v reflect.Value) {
+ // Check for unmarshaler.
+ unmarshaler, pv := d.indirect(v, false)
+ if unmarshaler != nil {
+ d.off--
+ err := unmarshaler.UnmarshalJSON(d.next())
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ v = pv
+
+ // Decoding into nil interface? Switch to non-reflect code.
+ iv, ok := v.(*reflect.InterfaceValue)
+ if ok {
+ iv.Set(reflect.NewValue(d.objectInterface()))
+ return
+ }
+
+ // Check type of target: struct or map[string]T
+ var (
+ mv *reflect.MapValue
+ sv *reflect.StructValue
+ )
+ switch v := v.(type) {
+ case *reflect.MapValue:
+ // map must have string type
+ t := v.Type().(*reflect.MapType)
+ if t.Key() != reflect.Typeof("") {
+ d.saveError(&UnmarshalTypeError{"object", v.Type()})
+ break
+ }
+ mv = v
+ if mv.IsNil() {
+ mv.SetValue(reflect.MakeMap(t))
+ }
+ case *reflect.StructValue:
+ sv = v
+ default:
+ d.saveError(&UnmarshalTypeError{"object", v.Type()})
+ }
+
+ if mv == nil && sv == nil {
+ d.off--
+ d.next() // skip over { } in input
+ return
+ }
+
+ for {
+ // Read opening " of string key or closing }.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ // closing } - can only happen on first iteration.
+ break
+ }
+ if op != scanBeginLiteral {
+ d.error(errPhase)
+ }
+
+ // Read string key.
+ start := d.off - 1
+ op = d.scanWhile(scanContinue)
+ item := d.data[start : d.off-1]
+ key, ok := unquote(item)
+ if !ok {
+ d.error(errPhase)
+ }
+
+ // Figure out
+ var subv reflect.Value
+ if mv != nil {
+ subv = reflect.MakeZero(mv.Type().(*reflect.MapType).Elem())
+ } else {
+ for i := 0; i < sv.NumField(); i++ {
+ f := sv.Type().(*reflect.StructType).Field(i)
+ if f.Tag == key {
+ subv = sv.Field(i)
+ break
+ }
+ }
+ if subv == nil {
+ subv = sv.FieldByNameFunc(func(s string) bool { return matchName(key, s) })
+ }
+ }
+
+ // Read : before value.
+ if op == scanSkipSpace {
+ op = d.scanWhile(scanSkipSpace)
+ }
+ if op != scanObjectKey {
+ d.error(errPhase)
+ }
+
+ // Read value.
+ d.value(subv)
+
+ // Write value back to map;
+ // if using struct, subv points into struct already.
+ if mv != nil {
+ mv.SetElem(reflect.NewValue(key), subv)
+ }
+
+ // Next token must be , or }.
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ break
+ }
+ if op != scanObjectValue {
+ d.error(errPhase)
+ }
+ }
+}
+
+// literal consumes a literal from d.data[d.off-1:], decoding into the value v.
+// The first byte of the literal has been read already
+// (that's how the caller knows it's a literal).
+func (d *decodeState) literal(v reflect.Value) {
+ // All bytes inside literal return scanContinue op code.
+ start := d.off - 1
+ op := d.scanWhile(scanContinue)
+
+ // Scan read one byte too far; back up.
+ d.off--
+ d.scan.undo(op)
+ item := d.data[start:d.off]
+
+ // Check for unmarshaler.
+ wantptr := item[0] == 'n' // null
+ unmarshaler, pv := d.indirect(v, wantptr)
+ if unmarshaler != nil {
+ err := unmarshaler.UnmarshalJSON(item)
+ if err != nil {
+ d.error(err)
+ }
+ return
+ }
+ v = pv
+
+ switch c := item[0]; c {
+ case 'n': // null
+ switch v.(type) {
+ default:
+ d.saveError(&UnmarshalTypeError{"null", v.Type()})
+ case *reflect.InterfaceValue, *reflect.PtrValue, *reflect.MapValue:
+ v.SetValue(nil)
+ }
+
+ case 't', 'f': // true, false
+ value := c == 't'
+ switch v := v.(type) {
+ default:
+ d.saveError(&UnmarshalTypeError{"bool", v.Type()})
+ case *reflect.BoolValue:
+ v.Set(value)
+ case *reflect.InterfaceValue:
+ v.Set(reflect.NewValue(value))
+ }
+
+ case '"': // string
+ s, ok := unquote(item)
+ if !ok {
+ d.error(errPhase)
+ }
+ switch v := v.(type) {
+ default:
+ d.saveError(&UnmarshalTypeError{"string", v.Type()})
+ case *reflect.StringValue:
+ v.Set(s)
+ case *reflect.InterfaceValue:
+ v.Set(reflect.NewValue(s))
+ }
+
+ default: // number
+ if c != '-' && (c < '0' || c > '9') {
+ d.error(errPhase)
+ }
+ s := string(item)
+ switch v := v.(type) {
+ default:
+ d.error(&UnmarshalTypeError{"number", v.Type()})
+ case *reflect.InterfaceValue:
+ n, err := strconv.Atof64(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(reflect.NewValue(n))
+
+ case *reflect.IntValue:
+ n, err := strconv.Atoi(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+ case *reflect.Int8Value:
+ n, err := strconv.Atoi(s)
+ if err != nil || int(int8(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(int8(n))
+ case *reflect.Int16Value:
+ n, err := strconv.Atoi(s)
+ if err != nil || int(int16(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(int16(n))
+ case *reflect.Int32Value:
+ n, err := strconv.Atoi(s)
+ if err != nil || int(int32(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(int32(n))
+ case *reflect.Int64Value:
+ n, err := strconv.Atoi64(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+
+ case *reflect.UintValue:
+ n, err := strconv.Atoui(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+ case *reflect.Uint8Value:
+ n, err := strconv.Atoui(s)
+ if err != nil || uint(uint8(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(uint8(n))
+ case *reflect.Uint16Value:
+ n, err := strconv.Atoui(s)
+ if err != nil || uint(uint16(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(uint16(n))
+ case *reflect.Uint32Value:
+ n, err := strconv.Atoui(s)
+ if err != nil || uint(uint32(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(uint32(n))
+ case *reflect.Uint64Value:
+ n, err := strconv.Atoui64(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+ case *reflect.UintptrValue:
+ n, err := strconv.Atoui64(s)
+ if err != nil || uint64(uintptr(n)) != n {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(uintptr(n))
+
+ case *reflect.FloatValue:
+ n, err := strconv.Atof(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+ case *reflect.Float32Value:
+ n, err := strconv.Atof32(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+ case *reflect.Float64Value:
+ n, err := strconv.Atof64(s)
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + s, v.Type()})
+ break
+ }
+ v.Set(n)
+ }
}
- 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())
- case map[string]interface{}:
- index := j.index.(string)
- c[index] = j.Data()
+// The xxxInterface routines build up a value to be stored
+// in an empty interface. They are not strictly necessary,
+// but they avoid the weight of reflection in this common case.
+
+// valueInterface is like value but returns interface{}
+func (d *decodeState) valueInterface() interface{} {
+ switch d.scanWhile(scanSkipSpace) {
+ default:
+ d.error(errPhase)
+ case scanBeginArray:
+ return d.arrayInterface()
+ case scanBeginObject:
+ return d.objectInterface()
+ case scanBeginLiteral:
+ return d.literalInterface()
+ }
+ panic("unreachable")
+}
+
+// arrayInterface is like array but returns []interface{}.
+func (d *decodeState) arrayInterface() []interface{} {
+ var v vector.Vector
+ for {
+ // Look ahead for ] - can only happen on first iteration.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+
+ // Back up so d.value can have the byte we just read.
+ d.off--
+ d.scan.undo(op)
+
+ v.Push(d.valueInterface())
+
+ // Next token must be , or ].
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndArray {
+ break
+ }
+ if op != scanArrayValue {
+ d.error(errPhase)
+ }
+ }
+ return v
+}
+
+// objectInterface is like object but returns map[string]interface{}.
+func (d *decodeState) objectInterface() map[string]interface{} {
+ m := make(map[string]interface{})
+ for {
+ // Read opening " of string key or closing }.
+ op := d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ // closing } - can only happen on first iteration.
+ break
+ }
+ if op != scanBeginLiteral {
+ d.error(errPhase)
+ }
+
+ // Read string key.
+ start := d.off - 1
+ op = d.scanWhile(scanContinue)
+ item := d.data[start : d.off-1]
+ key, ok := unquote(item)
+ if !ok {
+ d.error(errPhase)
+ }
+
+ // Read : before value.
+ if op == scanSkipSpace {
+ op = d.scanWhile(scanSkipSpace)
+ }
+ if op != scanObjectKey {
+ d.error(errPhase)
+ }
+
+ // Read value.
+ m[key] = d.valueInterface()
+
+ // Next token must be , or }.
+ op = d.scanWhile(scanSkipSpace)
+ if op == scanEndObject {
+ break
+ }
+ if op != scanObjectValue {
+ d.error(errPhase)
+ }
}
+ return m
}
-// Get the value built by this builder.
-func (j *decoder) Data() interface{} {
- switch v := j.value.(type) {
- case *vector.Vector:
- return v.Data()
+
+// literalInterface is like literal but returns an interface value.
+func (d *decodeState) literalInterface() interface{} {
+ // All bytes inside literal return scanContinue op code.
+ start := d.off - 1
+ op := d.scanWhile(scanContinue)
+
+ // Scan read one byte too far; back up.
+ d.off--
+ d.scan.undo(op)
+ item := d.data[start:d.off]
+
+ switch c := item[0]; c {
+ case 'n': // null
+ return nil
+
+ case 't', 'f': // true, false
+ return c == 't'
+
+ case '"': // string
+ s, ok := unquote(item)
+ if !ok {
+ d.error(errPhase)
+ }
+ return s
+
+ default: // number
+ if c != '-' && (c < '0' || c > '9') {
+ d.error(errPhase)
+ }
+ n, err := strconv.Atof64(string(item))
+ if err != nil {
+ d.saveError(&UnmarshalTypeError{"number " + string(item), reflect.Typeof(float64(0))})
+ }
+ return n
+ }
+ panic("unreachable")
+}
+
+// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
+// or it returns -1.
+func getu4(s []byte) int {
+ if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
+ return -1
+ }
+ rune, err := strconv.Btoui64(string(s[2:6]), 16)
+ if err != nil {
+ return -1
+ }
+ return int(rune)
+}
+
+// unquote converts a quoted JSON string literal s into an actual string t.
+// The rules are different than for Go, so cannot use strconv.Unquote.
+func unquote(s []byte) (t string, ok bool) {
+ if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
+ return
+ }
+ b := make([]byte, len(s)+2*utf8.UTFMax)
+ w := 0
+ for r := 1; r < len(s)-1; {
+ // Out of room? Can only happen if s is full of
+ // malformed UTF-8 and we're replacing each
+ // byte with RuneError.
+ if w >= len(b)-2*utf8.UTFMax {
+ nb := make([]byte, (len(b)+utf8.UTFMax)*2)
+ copy(nb, b[0:w])
+ b = nb
+ }
+ switch c := s[r]; {
+ case c == '\\':
+ r++
+ if r >= len(s)-1 {
+ return
+ }
+ switch s[r] {
+ default:
+ return
+ case '"', '\\', '/', '\'':
+ b[w] = s[r]
+ r++
+ w++
+ case 'b':
+ b[w] = '\b'
+ r++
+ w++
+ case 'f':
+ b[w] = '\f'
+ r++
+ w++
+ case 'n':
+ b[w] = '\n'
+ r++
+ w++
+ case 'r':
+ b[w] = '\r'
+ r++
+ w++
+ case 't':
+ b[w] = '\t'
+ r++
+ w++
+ case 'u':
+ r--
+ rune := getu4(s[r:])
+ if rune < 0 {
+ return
+ }
+ r += 6
+ if utf16.IsSurrogate(rune) {
+ rune1 := getu4(s[r:])
+ if dec := utf16.DecodeRune(rune, rune1); dec != unicode.ReplacementChar {
+ // A valid pair; consume.
+ r += 6
+ w += utf8.EncodeRune(dec, b[w:])
+ break
+ }
+ // Invalid surrogate; fall back to replacement rune.
+ rune = unicode.ReplacementChar
+ }
+ w += utf8.EncodeRune(rune, b[w:])
+ }
+
+ // Quote, control characters are invalid.
+ case c == '"', c < ' ':
+ return
+
+ // ASCII
+ case c < utf8.RuneSelf:
+ b[w] = c
+ r++
+ w++
+
+ // Coerce to well-formed UTF-8.
+ default:
+ rune, size := utf8.DecodeRune(s[r:])
+ r += size
+ w += utf8.EncodeRune(rune, b[w:])
+ }
}
- return j.value
+ return string(b[0:w]), true
}
-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package json
import (
- "container/vector"
+ "bytes"
"reflect"
+ "strings"
"testing"
)
-func TestDecodeInt64(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Int64(-15)
- assertResult(t, nb.Data(), float64(-15))
+type unmarshalTest struct {
+ in string
+ ptr interface{}
+ out interface{}
}
-func TestDecodeUint64(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Uint64(15)
- assertResult(t, nb.Data(), float64(15))
-}
+var unmarshalTests = []unmarshalTest{
+ // basic types
+ unmarshalTest{`true`, new(bool), true},
+ unmarshalTest{`1`, new(int), 1},
+ unmarshalTest{`1.2`, new(float), 1.2},
+ unmarshalTest{`-5`, new(int16), int16(-5)},
+ unmarshalTest{`"a\u1234"`, new(string), "a\u1234"},
+ unmarshalTest{`"g-clef: \uD834\uDD1E"`, new(string), "g-clef: \U0001D11E"},
+ unmarshalTest{`"invalid: \uD834x\uDD1E"`, new(string), "invalid: \uFFFDx\uFFFD"},
+ unmarshalTest{"null", new(interface{}), nil},
-func TestDecodeFloat64(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Float64(3.14159)
- assertResult(t, nb.Data(), float64(3.14159))
+ // composite tests
+ unmarshalTest{allValueIndent, new(All), allValue},
+ unmarshalTest{allValueCompact, new(All), allValue},
+ unmarshalTest{allValueIndent, new(*All), &allValue},
+ unmarshalTest{allValueCompact, new(*All), &allValue},
+ unmarshalTest{pallValueIndent, new(All), pallValue},
+ unmarshalTest{pallValueCompact, new(All), pallValue},
+ unmarshalTest{pallValueIndent, new(*All), &pallValue},
+ unmarshalTest{pallValueCompact, new(*All), &pallValue},
}
-func TestDecodeString(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.String("Some string")
- assertResult(t, nb.Data(), "Some string")
-}
+func TestMarshal(t *testing.T) {
+ b, err := Marshal(allValue)
+ if err != nil {
+ t.Fatalf("Marshal allValue: %v", err)
+ }
+ if string(b) != allValueCompact {
+ t.Errorf("Marshal allValueCompact")
+ diff(t, b, []byte(allValueCompact))
+ return
+ }
-func TestDecodeBool(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Bool(true)
- assertResult(t, nb.Data(), true)
+ b, err = Marshal(pallValue)
+ if err != nil {
+ t.Fatalf("Marshal pallValue: %v", err)
+ }
+ if string(b) != pallValueCompact {
+ t.Errorf("Marshal pallValueCompact")
+ diff(t, b, []byte(pallValueCompact))
+ return
+ }
}
-func TestDecodeNull(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Null()
- assertResult(t, nb.Data(), nil)
+func TestUnmarshal(t *testing.T) {
+ var scan scanner
+ for i, tt := range unmarshalTests {
+ in := []byte(tt.in)
+ if err := checkValid(in, &scan); err != nil {
+ t.Errorf("#%d: checkValid: %v", i, err)
+ continue
+ }
+ // v = new(right-type)
+ v := reflect.NewValue(tt.ptr).(*reflect.PtrValue)
+ v.PointTo(reflect.MakeZero(v.Type().(*reflect.PtrType).Elem()))
+ if err := Unmarshal([]byte(in), v.Interface()); err != nil {
+ t.Errorf("#%d: %v", i, err)
+ continue
+ }
+ if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
+ t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
+ data, _ := Marshal(v.Elem().Interface())
+ println(string(data))
+ data, _ = Marshal(tt.out)
+ println(string(data))
+ return
+ continue
+ }
+ }
}
-func TestDecodeEmptyArray(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Array()
- assertResult(t, nb.Data(), []interface{}{})
+func TestUnmarshalMarshal(t *testing.T) {
+ var v interface{}
+ if err := Unmarshal(jsonBig, &v); err != nil {
+ t.Fatalf("Unmarshal: %v", err)
+ }
+ b, err := Marshal(v)
+ if err != nil {
+ t.Fatalf("Marshal: %v", err)
+ }
+ if bytes.Compare(jsonBig, b) != 0 {
+ t.Errorf("Marshal jsonBig")
+ diff(t, b, jsonBig)
+ return
+ }
}
-func TestDecodeEmptyMap(t *testing.T) {
- nb := newDecoder(nil, nil)
- nb.Map()
- assertResult(t, nb.Data(), map[string]interface{}{})
+func noSpace(c int) int {
+ if isSpace(c) {
+ return -1
+ }
+ return c
}
-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)})
-}
+type All struct {
+ Bool bool
+ Int int
+ Int8 int8
+ Int16 int16
+ Int32 int32
+ Int64 int64
+ Uint uint
+ Uint8 uint8
+ Uint16 uint16
+ Uint32 uint32
+ Uint64 uint64
+ Uintptr uintptr
+ Float float
+ Float32 float32
+ Float64 float64
-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)})
-}
+ Foo string "bar"
-// Elem() and Key() are hard to test in isolation because all they do
-// is create a new, properly initialized, decoder, and modify state of
-// the underlying decoder. I'm testing them through already tested
-// 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"})
-}
+ PBool *bool
+ PInt *int
+ PInt8 *int8
+ PInt16 *int16
+ PInt32 *int32
+ PInt64 *int64
+ PUint *uint
+ PUint8 *uint8
+ PUint16 *uint16
+ PUint32 *uint32
+ PUint64 *uint64
+ PUintptr *uintptr
+ PFloat *float
+ PFloat32 *float32
+ PFloat64 *float64
+
+ String string
+ PString *string
-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"})
+ Map map[string]Small
+ MapP map[string]*Small
+ PMap *map[string]Small
+ PMapP *map[string]*Small
+
+ EmptyMap map[string]Small
+ NilMap map[string]Small
+
+ Slice []Small
+ SliceP []*Small
+ PSlice *[]Small
+ PSliceP *[]*Small
+
+ EmptySlice []Small
+ NilSlice []Small
+
+ StringSlice []string
+ ByteSlice []byte
+
+ Small Small
+ PSmall *Small
+ PPSmall **Small
+
+ Interface interface{}
+ PInterface *interface{}
}
-func assertResult(t *testing.T, results, expected interface{}) {
- if !reflect.DeepEqual(results, expected) {
- t.Fatalf("have %T(%#v) want %T(%#v)", results, results, expected, expected)
- }
+type Small struct {
+ Tag string
}
-type decodeTest struct {
- s string
- r interface{}
+var allValue = All{
+ Bool: true,
+ Int: 2,
+ Int8: 3,
+ Int16: 4,
+ Int32: 5,
+ Int64: 6,
+ Uint: 7,
+ Uint8: 8,
+ Uint16: 9,
+ Uint32: 10,
+ Uint64: 11,
+ Uintptr: 12,
+ Float: 13.1,
+ Float32: 14.1,
+ Float64: 15.1,
+ Foo: "foo",
+ String: "16",
+ Map: map[string]Small{
+ "17": Small{Tag: "tag17"},
+ "18": Small{Tag: "tag18"},
+ },
+ MapP: map[string]*Small{
+ "19": &Small{Tag: "tag19"},
+ "20": nil,
+ },
+ EmptyMap: map[string]Small{},
+ Slice: []Small{Small{Tag: "tag20"}, Small{Tag: "tag21"}},
+ SliceP: []*Small{&Small{Tag: "tag22"}, nil, &Small{Tag: "tag23"}},
+ EmptySlice: []Small{},
+ StringSlice: []string{"str24", "str25", "str26"},
+ ByteSlice: []byte{27, 28, 29},
+ Small: Small{Tag: "tag30"},
+ PSmall: &Small{Tag: "tag31"},
+ Interface: float64(5.2),
}
-var tests = []decodeTest{
- decodeTest{`null`, nil},
- decodeTest{`true`, true},
- decodeTest{`false`, false},
- decodeTest{`"abc"`, "abc"},
- decodeTest{`123`, float64(123)},
- decodeTest{`0.1`, float64(0.1)},
- decodeTest{`1e-10`, float64(1e-10)},
- decodeTest{`[]`, []interface{}{}},
- decodeTest{`[1,2,3,4]`, []interface{}{float64(1), float64(2), float64(3), float64(4)}},
- decodeTest{`[1,2,"abc",null,true,false]`, []interface{}{float64(1), float64(2), "abc", nil, true, false}},
- decodeTest{`{}`, map[string]interface{}{}},
- decodeTest{`{"a":1}`, map[string]interface{}{"a": float64(1)}},
- decodeTest{`"q\u0302"`, "q\u0302"},
+var pallValue = All{
+ PBool: &allValue.Bool,
+ PInt: &allValue.Int,
+ PInt8: &allValue.Int8,
+ PInt16: &allValue.Int16,
+ PInt32: &allValue.Int32,
+ PInt64: &allValue.Int64,
+ PUint: &allValue.Uint,
+ PUint8: &allValue.Uint8,
+ PUint16: &allValue.Uint16,
+ PUint32: &allValue.Uint32,
+ PUint64: &allValue.Uint64,
+ PUintptr: &allValue.Uintptr,
+ PFloat: &allValue.Float,
+ PFloat32: &allValue.Float32,
+ PFloat64: &allValue.Float64,
+ PString: &allValue.String,
+ PMap: &allValue.Map,
+ PMapP: &allValue.MapP,
+ PSlice: &allValue.Slice,
+ PSliceP: &allValue.SliceP,
+ PPSmall: &allValue.PSmall,
+ PInterface: &allValue.Interface,
}
-func TestDecode(t *testing.T) {
- for _, test := range tests {
- if val, err := Decode(test.s); err != nil || !reflect.DeepEqual(val, test.r) {
- t.Errorf("Decode(%#q) = %v, %v want %v, nil", test.s, val, err, test.r)
+var allValueIndent = `{
+ "bool": true,
+ "int": 2,
+ "int8": 3,
+ "int16": 4,
+ "int32": 5,
+ "int64": 6,
+ "uint": 7,
+ "uint8": 8,
+ "uint16": 9,
+ "uint32": 10,
+ "uint64": 11,
+ "uintptr": 12,
+ "float": 13.1,
+ "float32": 14.1,
+ "float64": 15.1,
+ "bar": "foo",
+ "pbool": null,
+ "pint": null,
+ "pint8": null,
+ "pint16": null,
+ "pint32": null,
+ "pint64": null,
+ "puint": null,
+ "puint8": null,
+ "puint16": null,
+ "puint32": null,
+ "puint64": null,
+ "puintptr": null,
+ "pfloat": null,
+ "pfloat32": null,
+ "pfloat64": null,
+ "string": "16",
+ "pstring": null,
+ "map": {
+ "17": {
+ "tag": "tag17"
+ },
+ "18": {
+ "tag": "tag18"
}
- }
-}
+ },
+ "mapp": {
+ "19": {
+ "tag": "tag19"
+ },
+ "20": null
+ },
+ "pmap": null,
+ "pmapp": null,
+ "emptymap": {},
+ "nilmap": null,
+ "slice": [
+ {
+ "tag": "tag20"
+ },
+ {
+ "tag": "tag21"
+ }
+ ],
+ "slicep": [
+ {
+ "tag": "tag22"
+ },
+ null,
+ {
+ "tag": "tag23"
+ }
+ ],
+ "pslice": null,
+ "pslicep": null,
+ "emptyslice": [],
+ "nilslice": [],
+ "stringslice": [
+ "str24",
+ "str25",
+ "str26"
+ ],
+ "byteslice": [
+ 27,
+ 28,
+ 29
+ ],
+ "small": {
+ "tag": "tag30"
+ },
+ "psmall": {
+ "tag": "tag31"
+ },
+ "ppsmall": null,
+ "interface": 5.2,
+ "pinterface": null
+}`
+
+var allValueCompact = strings.Map(noSpace, allValueIndent)
+
+var pallValueIndent = `{
+ "bool": false,
+ "int": 0,
+ "int8": 0,
+ "int16": 0,
+ "int32": 0,
+ "int64": 0,
+ "uint": 0,
+ "uint8": 0,
+ "uint16": 0,
+ "uint32": 0,
+ "uint64": 0,
+ "uintptr": 0,
+ "float": 0,
+ "float32": 0,
+ "float64": 0,
+ "bar": "",
+ "pbool": true,
+ "pint": 2,
+ "pint8": 3,
+ "pint16": 4,
+ "pint32": 5,
+ "pint64": 6,
+ "puint": 7,
+ "puint8": 8,
+ "puint16": 9,
+ "puint32": 10,
+ "puint64": 11,
+ "puintptr": 12,
+ "pfloat": 13.1,
+ "pfloat32": 14.1,
+ "pfloat64": 15.1,
+ "string": "",
+ "pstring": "16",
+ "map": null,
+ "mapp": null,
+ "pmap": {
+ "17": {
+ "tag": "tag17"
+ },
+ "18": {
+ "tag": "tag18"
+ }
+ },
+ "pmapp": {
+ "19": {
+ "tag": "tag19"
+ },
+ "20": null
+ },
+ "emptymap": null,
+ "nilmap": null,
+ "slice": [],
+ "slicep": [],
+ "pslice": [
+ {
+ "tag": "tag20"
+ },
+ {
+ "tag": "tag21"
+ }
+ ],
+ "pslicep": [
+ {
+ "tag": "tag22"
+ },
+ null,
+ {
+ "tag": "tag23"
+ }
+ ],
+ "emptyslice": [],
+ "nilslice": [],
+ "stringslice": [],
+ "byteslice": [],
+ "small": {
+ "tag": ""
+ },
+ "psmall": null,
+ "ppsmall": {
+ "tag": "tag31"
+ },
+ "interface": null,
+ "pinterface": 5.2
+}`
+
+var pallValueCompact = strings.Map(noSpace, pallValueIndent)
--- /dev/null
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package json
+
+import (
+ "os"
+ "bytes"
+ "reflect"
+ "runtime"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+// Marshal returns the JSON encoding of v.
+//
+// Marshal traverses the value v recursively.
+// If an encountered value implements the Marshaler interface,
+// Marshal calls its MarshalJSON method to produce JSON.
+//
+// Otherwise, Marshal uses the following type-dependent default encodings:
+//
+// Boolean values encode as JSON booleans.
+//
+// Floating point and integer values encode as JSON numbers.
+//
+// String values encode as JSON strings, with each invalid UTF-8 sequence
+// replaced by the encoding of the Unicode replacement character U+FFFD.
+//
+// Array and slice values encode as JSON arrays.
+//
+// Struct values encode as JSON objects. Each struct field becomes
+// a member of the object. By default the object's key name is the
+// struct field name converted to lower case. If the struct field
+// has a tag, that tag will be used as the name instead.
+//
+// Map values encode as JSON objects.
+// The map's key type must be string; the object keys are used directly
+// as map keys.
+//
+// Pointer values encode as the value pointed at.
+// A nil pointer encodes as the null JSON object.
+//
+// Interface values encode as the value contained in the interface.
+// A nil interface value encodes as the null JSON object.
+//
+// Channel, complex, and function values cannot be encoded in JSON.
+// Attempting to encode such a value causes Marshal to return
+// an InvalidTypeError.
+//
+// JSON cannot represent cyclic data structures and Marshal does not
+// handle them. Passing cyclic structures to Marshal will result in
+// an infinite recursion.
+//
+func Marshal(v interface{}) ([]byte, os.Error) {
+ e := &encodeState{}
+ err := e.marshal(v)
+ if err != nil {
+ return nil, err
+ }
+ return e.Bytes(), nil
+}
+
+// MarshalIndent is like Marshal but applies Indent to format the output.
+func MarshalIndent(v interface{}, prefix, indent string) ([]byte, os.Error) {
+ b, err := Marshal(v)
+ if err != nil {
+ return nil, err
+ }
+ var buf bytes.Buffer
+ err = Indent(&buf, b, prefix, indent)
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+// Marshaler is the interface implemented by objects that
+// can marshal themselves into valid JSON.
+type Marshaler interface {
+ MarshalJSON() ([]byte, os.Error)
+}
+
+type UnsupportedTypeError struct {
+ Type reflect.Type
+}
+
+func (e *UnsupportedTypeError) String() string {
+ return "json: unsupported type: " + e.Type.String()
+}
+
+type MarshalerError struct {
+ Type reflect.Type
+ Error os.Error
+}
+
+func (e *MarshalerError) String() string {
+ return "json: error calling MarshalJSON for type " + e.Type.String() + ": " + e.Error.String()
+}
+
+type interfaceOrPtrValue interface {
+ IsNil() bool
+ Elem() reflect.Value
+}
+
+var hex = "0123456789abcdef"
+
+// An encodeState encodes JSON into a bytes.Buffer.
+type encodeState struct {
+ bytes.Buffer // accumulated output
+}
+
+func (e *encodeState) marshal(v interface{}) (err os.Error) {
+ defer func() {
+ if r := recover(); r != nil {
+ if _, ok := r.(runtime.Error); ok {
+ panic(r)
+ }
+ err = r.(os.Error)
+ }
+ }()
+ e.reflectValue(reflect.NewValue(v))
+ return nil
+}
+
+func (e *encodeState) error(err os.Error) {
+ panic(err)
+}
+
+func (e *encodeState) reflectValue(v reflect.Value) {
+ if v == nil {
+ e.WriteString("null")
+ return
+ }
+
+ if j, ok := v.Interface().(Marshaler); ok {
+ b, err := j.MarshalJSON()
+ if err == nil {
+ // copy JSON into buffer, checking validity.
+ err = Compact(&e.Buffer, b)
+ }
+ if err != nil {
+ e.error(&MarshalerError{v.Type(), err})
+ }
+ return
+ }
+
+ switch v := v.(type) {
+ case *reflect.BoolValue:
+ x := v.Get()
+ if x {
+ e.WriteString("true")
+ } else {
+ e.WriteString("false")
+ }
+
+ case *reflect.IntValue:
+ e.WriteString(strconv.Itoa(v.Get()))
+ case *reflect.Int8Value:
+ e.WriteString(strconv.Itoa(int(v.Get())))
+ case *reflect.Int16Value:
+ e.WriteString(strconv.Itoa(int(v.Get())))
+ case *reflect.Int32Value:
+ e.WriteString(strconv.Itoa(int(v.Get())))
+ case *reflect.Int64Value:
+ e.WriteString(strconv.Itoa64(v.Get()))
+
+ case *reflect.UintValue:
+ e.WriteString(strconv.Uitoa(v.Get()))
+ case *reflect.Uint8Value:
+ e.WriteString(strconv.Uitoa(uint(v.Get())))
+ case *reflect.Uint16Value:
+ e.WriteString(strconv.Uitoa(uint(v.Get())))
+ case *reflect.Uint32Value:
+ e.WriteString(strconv.Uitoa(uint(v.Get())))
+ case *reflect.Uint64Value:
+ e.WriteString(strconv.Uitoa64(v.Get()))
+ case *reflect.UintptrValue:
+ e.WriteString(strconv.Uitoa64(uint64(v.Get())))
+
+ case *reflect.FloatValue:
+ e.WriteString(strconv.Ftoa(v.Get(), 'g', -1))
+ case *reflect.Float32Value:
+ e.WriteString(strconv.Ftoa32(v.Get(), 'g', -1))
+ case *reflect.Float64Value:
+ e.WriteString(strconv.Ftoa64(v.Get(), 'g', -1))
+
+ case *reflect.StringValue:
+ e.string(v.Get())
+
+ case *reflect.StructValue:
+ e.WriteByte('{')
+ t := v.Type().(*reflect.StructType)
+ n := v.NumField()
+ for i := 0; i < n; i++ {
+ if i > 0 {
+ e.WriteByte(',')
+ }
+ f := t.Field(i)
+ if f.Tag != "" {
+ e.string(f.Tag)
+ } else {
+ e.string(strings.ToLower(f.Name))
+ }
+ e.WriteByte(':')
+ e.reflectValue(v.Field(i))
+ }
+ e.WriteByte('}')
+
+ case *reflect.MapValue:
+ if _, ok := v.Type().(*reflect.MapType).Key().(*reflect.StringType); !ok {
+ e.error(&UnsupportedTypeError{v.Type()})
+ }
+ if v.IsNil() {
+ e.WriteString("null")
+ break
+ }
+ e.WriteByte('{')
+ var sv stringValues = v.Keys()
+ sort.Sort(sv)
+ for i, k := range sv {
+ if i > 0 {
+ e.WriteByte(',')
+ }
+ e.string(k.(*reflect.StringValue).Get())
+ e.WriteByte(':')
+ e.reflectValue(v.Elem(k))
+ }
+ e.WriteByte('}')
+
+ case reflect.ArrayOrSliceValue:
+ e.WriteByte('[')
+ n := v.Len()
+ for i := 0; i < n; i++ {
+ if i > 0 {
+ e.WriteByte(',')
+ }
+ e.reflectValue(v.Elem(i))
+ }
+ e.WriteByte(']')
+
+ case interfaceOrPtrValue:
+ if v.IsNil() {
+ e.WriteString("null")
+ return
+ }
+ e.reflectValue(v.Elem())
+
+ default:
+ e.error(&UnsupportedTypeError{v.Type()})
+ }
+ return
+}
+
+// stringValues is a slice of reflect.Value holding *reflect.StringValue.
+// It implements the methods to sort by string.
+type stringValues []reflect.Value
+
+func (sv stringValues) Len() int { return len(sv) }
+func (sv stringValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] }
+func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
+func (sv stringValues) get(i int) string { return sv[i].(*reflect.StringValue).Get() }
+
+func (e *encodeState) string(s string) {
+ e.WriteByte('"')
+ for _, c := range s {
+ switch {
+ case c < 0x20:
+ e.WriteString(`\u00`)
+ e.WriteByte(hex[c>>4])
+ e.WriteByte(hex[c&0xF])
+ case c == '\\' || c == '"':
+ e.WriteByte('\\')
+ fallthrough
+ default:
+ e.WriteRune(c)
+ }
+ }
+ e.WriteByte('"')
+}
}
}
+func isSpace(c int) bool {
+ return c == ' ' || c == '\t' || c == '\r' || c == '\n'
+}
+
// NOTE(rsc): The various instances of
//
// if c <= ' ' && (c == ' ' || c == '\t' || c == '\r' || c == '\n')
// error records an error and switches to the error state.
func (s *scanner) error(c int, context string) int {
s.step = stateError
- s.err = SyntaxError("invalid character '" + quoteChar(c) + "' " + context)
+ s.err = SyntaxError("invalid character " + quoteChar(c) + " " + context)
return scanError
}
j = 0
}
t.Errorf("diverge at %d: «%s» vs «%s»", i, trim(a[j:]), trim(b[j:]))
+ return
}
}
}
var jsonBig []byte
func init() {
- var buf bytes.Buffer
- Marshal(&buf, genValue(100000))
- jsonBig = buf.Bytes()
+ b, err := Marshal(genValue(10000))
+ if err != nil {
+ panic(err)
+ }
+ jsonBig = b
}
func genValue(n int) interface{} {
+++ /dev/null
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Marshalling and unmarshalling of
-// JSON data into Go structs using reflection.
-
-package json
-
-import (
- "bytes"
- "fmt"
- "io"
- "os"
- "reflect"
- "strings"
-)
-
-type structBuilder struct {
- val reflect.Value
-
- // if map_ != nil, write val to map_[key] on each change
- map_ *reflect.MapValue
- key reflect.Value
-}
-
-var nobuilder *structBuilder
-
-func isfloat(v reflect.Value) bool {
- switch v.(type) {
- case *reflect.FloatValue, *reflect.Float32Value, *reflect.Float64Value:
- return true
- }
- return false
-}
-
-func setfloat(v reflect.Value, f float64) {
- switch v := v.(type) {
- case *reflect.FloatValue:
- v.Set(float(f))
- case *reflect.Float32Value:
- v.Set(float32(f))
- case *reflect.Float64Value:
- v.Set(float64(f))
- }
-}
-
-func setint(v reflect.Value, i int64) {
- switch v := v.(type) {
- case *reflect.IntValue:
- v.Set(int(i))
- case *reflect.Int8Value:
- v.Set(int8(i))
- case *reflect.Int16Value:
- v.Set(int16(i))
- case *reflect.Int32Value:
- v.Set(int32(i))
- case *reflect.Int64Value:
- v.Set(int64(i))
- case *reflect.UintValue:
- v.Set(uint(i))
- case *reflect.Uint8Value:
- v.Set(uint8(i))
- case *reflect.Uint16Value:
- v.Set(uint16(i))
- case *reflect.Uint32Value:
- v.Set(uint32(i))
- case *reflect.Uint64Value:
- v.Set(uint64(i))
- }
-}
-
-// If updating b.val is not enough to update the original,
-// copy a changed b.val out to the original.
-func (b *structBuilder) Flush() {
- if b == nil {
- return
- }
- if b.map_ != nil {
- b.map_.SetElem(b.key, b.val)
- }
-}
-
-func (b *structBuilder) Int64(i int64) {
- if b == nil {
- return
- }
- v := b.val
- if isfloat(v) {
- setfloat(v, float64(i))
- } else {
- setint(v, i)
- }
-}
-
-func (b *structBuilder) Uint64(i uint64) {
- if b == nil {
- return
- }
- v := b.val
- if isfloat(v) {
- setfloat(v, float64(i))
- } else {
- setint(v, int64(i))
- }
-}
-
-func (b *structBuilder) Float64(f float64) {
- if b == nil {
- return
- }
- v := b.val
- if isfloat(v) {
- setfloat(v, f)
- } else {
- setint(v, int64(f))
- }
-}
-
-func (b *structBuilder) Null() {}
-
-func (b *structBuilder) String(s string) {
- if b == nil {
- return
- }
- if v, ok := b.val.(*reflect.StringValue); ok {
- v.Set(s)
- }
-}
-
-func (b *structBuilder) Bool(tf bool) {
- if b == nil {
- return
- }
- if v, ok := b.val.(*reflect.BoolValue); ok {
- v.Set(tf)
- }
-}
-
-func (b *structBuilder) Array() {
- if b == nil {
- return
- }
- if v, ok := b.val.(*reflect.SliceValue); ok {
- if v.IsNil() {
- v.Set(reflect.MakeSlice(v.Type().(*reflect.SliceType), 0, 8))
- }
- }
-}
-
-func (b *structBuilder) Elem(i int) Builder {
- if b == nil || i < 0 {
- return nobuilder
- }
- switch v := b.val.(type) {
- case *reflect.ArrayValue:
- if i < v.Len() {
- return &structBuilder{val: v.Elem(i)}
- }
- case *reflect.SliceValue:
- if i >= 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)
- }
- if v.Len() <= i && i < v.Cap() {
- v.SetLen(i + 1)
- }
- if i < v.Len() {
- return &structBuilder{val: v.Elem(i)}
- }
- }
- return nobuilder
-}
-
-func (b *structBuilder) Map() {
- if b == nil {
- return
- }
- if v, ok := b.val.(*reflect.PtrValue); ok && v.IsNil() {
- if v.IsNil() {
- v.PointTo(reflect.MakeZero(v.Type().(*reflect.PtrType).Elem()))
- b.Flush()
- }
- 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)))
- }
-}
-
-func (b *structBuilder) Key(k string) Builder {
- if b == nil {
- return nobuilder
- }
- switch v := reflect.Indirect(b.val).(type) {
- case *reflect.StructValue:
- t := v.Type().(*reflect.StructType)
- // Case-insensitive field lookup.
- 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)
- if t.Key() != reflect.Typeof(k) {
- break
- }
- key := reflect.NewValue(k)
- elem := v.Elem(key)
- if elem == nil {
- v.SetElem(key, reflect.MakeZero(t.Elem()))
- elem = v.Elem(key)
- }
- return &structBuilder{val: elem, map_: v, key: key}
- }
- return nobuilder
-}
-
-// Unmarshal parses the JSON syntax string s and fills in
-// an arbitrary struct or slice pointed at by val.
-// It uses the reflect package to assign to fields
-// and arrays embedded in val. Well-formed data that does not fit
-// into the struct is discarded.
-//
-// For example, given these definitions:
-//
-// type Email struct {
-// Where string
-// Addr string
-// }
-//
-// type Result struct {
-// Name string
-// Phone string
-// Email []Email
-// }
-//
-// var r = Result{ "name", "phone", nil }
-//
-// unmarshalling the JSON syntax string
-//
-// {
-// "email": [
-// {
-// "where": "home",
-// "addr": "gre@example.com"
-// },
-// {
-// "where": "work",
-// "addr": "gre@work.com"
-// }
-// ],
-// "name": "Grace R. Emlin",
-// "address": "123 Main Street"
-// }
-//
-// via Unmarshal(s, &r) is equivalent to assigning
-//
-// r = Result{
-// "Grace R. Emlin", // name
-// "phone", // no phone given
-// []Email{
-// Email{ "home", "gre@example.com" },
-// Email{ "work", "gre@work.com" },
-// },
-// }
-//
-// Note that the field r.Phone has not been modified and
-// that the JSON field "address" was discarded.
-//
-// Because Unmarshal uses the reflect package, it can only
-// assign to upper case fields. Unmarshal uses a case-insensitive
-// comparison to match JSON field names to struct field names.
-//
-// To unmarshal a top-level JSON array, pass in a pointer to an empty
-// slice of the correct type.
-//
-// On success, Unmarshal returns with ok set to true.
-// 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
-
- // If val is a pointer to a slice, we append to the slice.
- if ptr, ok := v.(*reflect.PtrValue); ok {
- if slice, ok := ptr.Elem().(*reflect.SliceValue); ok {
- b = &structBuilder{val: slice}
- }
- }
-
- if b == nil {
- b = &structBuilder{val: v}
- }
-
- ok, _, errtok = Parse(s, b)
- if !ok {
- return false, errtok
- }
- return true, ""
-}
-
-type MarshalError struct {
- T reflect.Type
-}
-
-func (e *MarshalError) String() string {
- return "json cannot encode value of type " + e.T.String()
-}
-
-type writeState struct {
- bytes.Buffer
- indent string
- newlines bool
- depth int
-}
-
-func (s *writeState) descend(bra byte) {
- s.depth++
- s.WriteByte(bra)
-}
-
-func (s *writeState) ascend(ket byte) {
- s.depth--
- s.writeIndent()
- s.WriteByte(ket)
-}
-
-func (s *writeState) writeIndent() {
- if s.newlines {
- s.WriteByte('\n')
- }
- for i := 0; i < s.depth; i++ {
- s.WriteString(s.indent)
- }
-}
-
-func (s *writeState) writeArrayOrSlice(val reflect.ArrayOrSliceValue) {
- s.descend('[')
-
- for i := 0; i < val.Len(); i++ {
- s.writeIndent()
- s.writeValue(val.Elem(i))
- if i < val.Len()-1 {
- s.WriteByte(',')
- }
- }
-
- s.ascend(']')
-}
-
-func (s *writeState) writeMap(val *reflect.MapValue) {
- key := val.Type().(*reflect.MapType).Key()
- if _, ok := key.(*reflect.StringType); !ok {
- panic(&MarshalError{val.Type()})
- }
-
- s.descend('{')
-
- keys := val.Keys()
- for i := 0; i < len(keys); i++ {
- s.writeIndent()
- fmt.Fprintf(s, "%s:", Quote(keys[i].(*reflect.StringValue).Get()))
- s.writeValue(val.Elem(keys[i]))
- if i < len(keys)-1 {
- s.WriteByte(',')
- }
- }
-
- s.ascend('}')
-}
-
-func (s *writeState) writeStruct(val *reflect.StructValue) {
- s.descend('{')
-
- typ := val.Type().(*reflect.StructType)
-
- for i := 0; i < val.NumField(); i++ {
- s.writeIndent()
- fmt.Fprintf(s, "%s:", Quote(typ.Field(i).Name))
- s.writeValue(val.Field(i))
- if i < val.NumField()-1 {
- s.WriteByte(',')
- }
- }
-
- s.ascend('}')
-}
-
-func (s *writeState) writeValue(val reflect.Value) {
- if val == nil {
- fmt.Fprint(s, "null")
- return
- }
-
- switch v := val.(type) {
- case *reflect.StringValue:
- fmt.Fprint(s, Quote(v.Get()))
- case *reflect.ArrayValue:
- s.writeArrayOrSlice(v)
- case *reflect.SliceValue:
- s.writeArrayOrSlice(v)
- case *reflect.MapValue:
- s.writeMap(v)
- case *reflect.StructValue:
- s.writeStruct(v)
- case *reflect.ChanValue,
- *reflect.UnsafePointerValue,
- *reflect.FuncValue:
- panic(&MarshalError{val.Type()})
- case *reflect.InterfaceValue:
- if v.IsNil() {
- fmt.Fprint(s, "null")
- } else {
- s.writeValue(v.Elem())
- }
- case *reflect.PtrValue:
- if v.IsNil() {
- fmt.Fprint(s, "null")
- } else {
- s.writeValue(v.Elem())
- }
- case *reflect.UintptrValue:
- fmt.Fprintf(s, "%d", v.Get())
- case *reflect.Uint64Value:
- fmt.Fprintf(s, "%d", v.Get())
- case *reflect.Uint32Value:
- fmt.Fprintf(s, "%d", v.Get())
- case *reflect.Uint16Value:
- fmt.Fprintf(s, "%d", v.Get())
- case *reflect.Uint8Value:
- fmt.Fprintf(s, "%d", v.Get())
- default:
- value := val.(reflect.Value)
- fmt.Fprintf(s, "%#v", value.Interface())
- }
-}
-
-func (s *writeState) marshal(w io.Writer, val interface{}) (err os.Error) {
- defer func() {
- if e := recover(); e != nil {
- err = e.(*MarshalError)
- }
- }()
- s.writeValue(reflect.NewValue(val))
- if s.newlines {
- s.WriteByte('\n')
- }
- _, err = s.WriteTo(w)
- return
-}
-
-// Marshal writes the JSON encoding of val to w.
-//
-// Due to limitations in JSON, val cannot include cyclic data
-// structures, channels, functions, or maps.
-func Marshal(w io.Writer, val interface{}) os.Error {
- s := &writeState{indent: "", newlines: false, depth: 0}
- return s.marshal(w, val)
-}
-
-// MarshalIndent writes the JSON encoding of val to w,
-// indenting nested values using the indent string.
-//
-// Due to limitations in JSON, val cannot include cyclic data
-// structures, channels, functions, or maps.
-func MarshalIndent(w io.Writer, val interface{}, indent string) os.Error {
- s := &writeState{indent: indent, newlines: true, depth: 0}
- return s.marshal(w, val)
-}
+++ /dev/null
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package json
-
-import (
- "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
-}
-
-const encoded = `{"t":true,"f":false,"s":"abc","i8":1,"i16":2,"i32":3,"i64":4,` +
- ` "u8":5,"u16":6,"u32":7,"u64":8,` +
- ` "i":-9,"u":10,"bogusfield":"should be ignored",` +
- ` "fl":11.5,"fl32":12.25,"fl64":13.75,` +
- ` "a":["x","y","z"],"my":{"s":"subguy"},` +
- `"map":{"k1":[1,2,3],"k2":[],"k3":[3,4]},` +
- `"mapstruct":{"m1":{"u8":8}},` +
- `"mapptrstruct":{"m1":{"u8":8}}}`
-
-var decodedMap = map[string][]int{
- "k1": []int{1, 2, 3},
- "k2": []int{},
- "k3": []int{3, 4},
-}
-
-var decodedMapStruct = map[string]myStruct{
- "m1": myStruct{U8: 8},
-}
-
-var decodedMapPtrStruct = map[string]*myStruct{
- "m1": &myStruct{U8: 8},
-}
-
-func check(t *testing.T, ok bool, name string, v interface{}) {
- if !ok {
- t.Errorf("%s = %v (BAD)", name, v)
- } else {
- t.Logf("%s = %v (good)", name, v)
- }
-}
-
-const whiteSpaceEncoded = " \t{\n\"s\"\r:\"string\"\v}"
-
-func TestUnmarshalWhitespace(t *testing.T) {
- 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)
-}
-
-func TestUnmarshal(t *testing.T) {
- 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)
- 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.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)
-}
-
-type Issue147Text struct {
- Text string
-}
-
-type Issue147 struct {
- Test []Issue147Text
-}
-
-const issue147Input = `{"test": [{"text":"0"},{"text":"1"},{"text":"2"},
-{"text":"3"},{"text":"4"},{"text":"5"},
-{"text":"6"},{"text":"7"},{"text":"8"},
-{"text":"9"},{"text":"10"},{"text":"11"},
-{"text":"12"},{"text":"13"},{"text":"14"},
-{"text":"15"},{"text":"16"},{"text":"17"},
-{"text":"18"},{"text":"19"},{"text":"20"},
-{"text":"21"},{"text":"22"},{"text":"23"},
-{"text":"24"},{"text":"25"},{"text":"26"},
-{"text":"27"},{"text":"28"},{"text":"29"}]}`
-
-func TestIssue147(t *testing.T) {
- var timeline Issue147
- Unmarshal(issue147Input, &timeline)
-
- if len(timeline.Test) != 30 {
- t.Errorf("wrong length: got %d want 30", len(timeline.Test))
- }
-
- for i, e := range timeline.Test {
- if e.Text != strconv.Itoa(i) {
- t.Errorf("index: %d got: %s want: %d", i, e.Text, i)
- }
- }
-}
-
-type Issue114 struct {
- Text string
-}
-
-const issue114Input = `[{"text" : "0"}, {"text" : "1"}, {"text" : "2"}, {"text" : "3"}]`
-
-func TestIssue114(t *testing.T) {
- var items []Issue114
- Unmarshal(issue114Input, &items)
-
- if len(items) != 4 {
- t.Errorf("wrong length: got %d want 4", len(items))
- }
-
- for i, e := range items {
- if e.Text != strconv.Itoa(i) {
- t.Errorf("index: %d got: %s want: %d", i, e.Text, i)
- }
- }
-}
-
-type marshalTest struct {
- val interface{}
- out string
-}
-
-type MTE string
-
-type OneField struct {
- a int
-}
-
-type ScalarWithString int
-
-const (
- AA ScalarWithString = iota
- BB
- CC
-)
-
-var scalarStrings = []string{"AA", "BB", "CC"}
-
-func (x ScalarWithString) String() string { return scalarStrings[x] }
-
-var marshalTests = []marshalTest{
- // basic string
- marshalTest{nil, "null"},
- marshalTest{true, "true"},
- marshalTest{false, "false"},
- marshalTest{123, "123"},
- marshalTest{0.1, "0.1"},
- marshalTest{1e-10, "1e-10"},
- marshalTest{"teststring", `"teststring"`},
- marshalTest{[4]int{1, 2, 3, 4}, "[1,2,3,4]"},
- marshalTest{[]int{1, 2, 3, 4}, "[1,2,3,4]"},
- marshalTest{[]interface{}{nil}, "[null]"},
- marshalTest{[][]int{[]int{1, 2}, []int{3, 4}}, "[[1,2],[3,4]]"},
- marshalTest{map[string]string{"one": "one"}, `{"one":"one"}`},
- marshalTest{map[string]int{"one": 1}, `{"one":1}`},
- marshalTest{map[string]interface{}{"null": nil}, `{"null":null}`},
- marshalTest{struct{}{}, "{}"},
- marshalTest{struct{ a int }{1}, `{"a":1}`},
- marshalTest{struct{ a interface{} }{nil}, `{"a":null}`},
- marshalTest{struct {
- a int
- b string
- }{1, "hello"},
- `{"a":1,"b":"hello"}`,
- },
- marshalTest{map[string][]int{"3": []int{1, 2, 3}}, `{"3":[1,2,3]}`},
- marshalTest{map[string]*MTE{"hi": nil}, `{"hi":null}`},
- marshalTest{map[string]interface{}{"hi": 3}, `{"hi":3}`},
- marshalTest{&OneField{3}, `{"a":3}`},
- marshalTest{"\x05\x06", `"\u0005\u0006"`},
- marshalTest{uintptr(50000), "50000"},
- marshalTest{uint64(50000), "50000"},
- marshalTest{uint32(50000), "50000"},
- marshalTest{uint16(50000), "50000"},
- marshalTest{uint8(50), "50"},
- marshalTest{int64(50000), "50000"},
- marshalTest{int32(50000), "50000"},
- marshalTest{int16(10000), "10000"},
- marshalTest{int8(50), "50"},
- marshalTest{BB, "1"},
-}
-
-func TestMarshal(t *testing.T) {
- for _, tt := range marshalTests {
- var buf bytes.Buffer
-
- err := Marshal(&buf, tt.val)
- if err != nil {
- t.Fatalf("Marshal(%T): %s", tt.val, err)
- }
-
- s := buf.String()
- if s != tt.out {
- t.Errorf("Marshal(%T) = %q, want %q\n", tt.val, s, tt.out)
- }
- }
-}
-
-type marshalIndentTest struct {
- val interface{}
- indent string
- out string
-}
-
-const marshalIndentTest1 = `[
- 1,
- 2,
- 3,
- 4
-]
-`
-const marshalIndentTest2 = `[
-[
-1,
-2
-],
-[
-3,
-4
-]
-]
-`
-const marshalIndentTest3 = `[
- [
- 1,
- 2
- ],
- [
- 3,
- 4
- ]
-]
-`
-const marshalIndentTest4 = `[
- [
- 1,
- 2
- ],
- [
- 3,
- 4
- ]
-]
-`
-const marshalIndentTest5 = `{
- "a":1,
- "b":"hello"
-}
-`
-const marshalIndentTest6 = `{
- "3":[
- 1,
- 2,
- 3
- ]
-}
-`
-
-var marshalIndentTests = []marshalIndentTest{
- marshalIndentTest{[]int{1, 2, 3, 4}, " ", marshalIndentTest1},
- marshalIndentTest{[][]int{[]int{1, 2}, []int{3, 4}}, "", marshalIndentTest2},
- marshalIndentTest{[][]int{[]int{1, 2}, []int{3, 4}}, " ", marshalIndentTest3},
- marshalIndentTest{[][]int{[]int{1, 2}, []int{3, 4}}, " ", marshalIndentTest4},
- marshalIndentTest{struct {
- a int
- b string
- }{1, "hello"},
- " ",
- marshalIndentTest5,
- },
- marshalIndentTest{map[string][]int{"3": []int{1, 2, 3}}, " ", marshalIndentTest6},
-}
-
-func TestMarshalIndent(t *testing.T) {
- for _, tt := range marshalIndentTests {
- var buf bytes.Buffer
-
- err := MarshalIndent(&buf, tt.val, tt.indent)
- if err != nil {
- t.Fatalf("MarshalIndent(%v): %s", tt.val, err)
- }
-
- s := buf.String()
- if s != tt.out {
- t.Errorf("MarshalIndent(%v) = %q, want %q\n", tt.val, s, tt.out)
- }
- }
-}
-
-type marshalErrorTest struct {
- val interface{}
- error string
-}
-
-type ChanVal struct {
- C chan int
-}
-
-var marshalErrorTests = []marshalErrorTest{
- marshalErrorTest{map[chan int]string{make(chan int): "one"}, "json cannot encode value of type map[chan int] string"},
- marshalErrorTest{make(chan int, 100), "json cannot encode value of type chan int"},
- marshalErrorTest{new(ChanVal), "json cannot encode value of type chan int"},
-}
-
-func TestMarshalError(t *testing.T) {
- for _, tt := range marshalErrorTests {
- var buf bytes.Buffer
-
- err := Marshal(&buf, tt.val)
-
- if err == nil {
- t.Fatalf("Marshal(%T): no error, want error %s", tt.val, tt.error)
- }
-
- if err.String() != tt.error {
- t.Fatalf("Marshal(%T) = error %s, want error %s", tt.val, err, tt.error)
- }
-
- }
-}
s.false = false
s.mp = make(map[string]string)
s.mp["mapkey"] = "Ahoy!"
- s.json, _ = json.Decode("{\"maps\":[{\"a\":1,\"b\":2},{\"a\":3,\"b\":4}]}")
+ json.Unmarshal([]byte(`{"maps":[{"a":1,"b":2},{"a":3,"b":4}]}`), &s.json)
s.innermap.mp = make(map[string]int)
s.innermap.mp["innerkey"] = 55
s.stringmap = make(map[string]string)