...
Run Format

Source file src/encoding/json/decode.go

Documentation: encoding/json

  // 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.
  
  // Represents JSON data structure using native Go types: booleans, floats,
  // strings, arrays, and maps.
  
  package json
  
  import (
  	"bytes"
  	"encoding"
  	"encoding/base64"
  	"errors"
  	"fmt"
  	"reflect"
  	"runtime"
  	"strconv"
  	"unicode"
  	"unicode/utf16"
  	"unicode/utf8"
  )
  
  // Unmarshal parses the JSON-encoded data and stores the result
  // in the value pointed to by v. If v is nil or not a pointer,
  // Unmarshal returns an InvalidUnmarshalError.
  //
  // Unmarshal uses the inverse of the encodings that
  // Marshal uses, allocating maps, slices, and pointers as necessary,
  // with the following additional rules:
  //
  // To unmarshal JSON into a pointer, Unmarshal first handles the case of
  // the JSON being the JSON literal null. In that case, Unmarshal sets
  // the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
  // the value pointed at by the pointer. If the pointer is nil, Unmarshal
  // allocates a new value for it to point to.
  //
  // To unmarshal JSON into a value implementing the Unmarshaler interface,
  // Unmarshal calls that value's UnmarshalJSON method, including
  // when the input is a JSON null.
  // Otherwise, if the value implements encoding.TextUnmarshaler
  // and the input is a JSON quoted string, Unmarshal calls that value's
  // UnmarshalText method with the unquoted form of the string.
  //
  // To unmarshal JSON into a struct, Unmarshal matches incoming object
  // keys to the keys used by Marshal (either the struct field name or its tag),
  // preferring an exact match but also accepting a case-insensitive match.
  // Unmarshal will only set exported fields of the struct.
  //
  // To unmarshal JSON into an interface value,
  // Unmarshal stores one of these in the interface value:
  //
  //	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
  //
  // To unmarshal a JSON array into a slice, Unmarshal resets the slice length
  // to zero and then appends each element to the slice.
  // As a special case, to unmarshal an empty JSON array into a slice,
  // Unmarshal replaces the slice with a new empty slice.
  //
  // To unmarshal a JSON array into a Go array, Unmarshal decodes
  // JSON array elements into corresponding Go array elements.
  // If the Go array is smaller than the JSON array,
  // the additional JSON array elements are discarded.
  // If the JSON array is smaller than the Go array,
  // the additional Go array elements are set to zero values.
  //
  // To unmarshal a JSON object into a map, Unmarshal first establishes a map to
  // use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
  // reuses the existing map, keeping existing entries. Unmarshal then stores
  // key-value pairs from the JSON object into the map. The map's key type must
  // either be a string, an integer, or implement encoding.TextUnmarshaler.
  //
  // 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 unmarshaling as best it can.
  // If no more serious errors are encountered, Unmarshal returns
  // an UnmarshalTypeError describing the earliest such error. In any
  // case, it's not guaranteed that all the remaining fields following
  // the problematic one will be unmarshaled into the target object.
  //
  // The JSON null value unmarshals into an interface, map, pointer, or slice
  // by setting that Go value to nil. Because null is often used in JSON to mean
  // ``not present,'' unmarshaling a JSON null into any other Go type has no effect
  // on the value and produces no error.
  //
  // When unmarshaling quoted strings, invalid UTF-8 or
  // invalid UTF-16 surrogate pairs are not treated as an error.
  // Instead, they are replaced by the Unicode replacement
  // character U+FFFD.
  //
  func Unmarshal(data []byte, v interface{}) error {
  	// Check for well-formedness.
  	// Avoids filling out half a data structure
  	// before discovering a JSON syntax error.
  	var d decodeState
  	err := checkValid(data, &d.scan)
  	if err != nil {
  		return err
  	}
  
  	d.init(data)
  	return d.unmarshal(v)
  }
  
  // Unmarshaler is the interface implemented by types
  // that can unmarshal a JSON description of themselves.
  // The input can be assumed to be a valid encoding of
  // a JSON value. UnmarshalJSON must copy the JSON data
  // if it wishes to retain the data after returning.
  //
  // By convention, to approximate the behavior of Unmarshal itself,
  // Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op.
  type Unmarshaler interface {
  	UnmarshalJSON([]byte) error
  }
  
  // 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
  	Offset int64        // error occurred after reading Offset bytes
  	Struct string       // name of the struct type containing the field
  	Field  string       // name of the field holding the Go value
  }
  
  func (e *UnmarshalTypeError) Error() string {
  	if e.Struct != "" || e.Field != "" {
  		return "json: cannot unmarshal " + e.Value + " into Go struct field " + e.Struct + "." + e.Field + " of type " + e.Type.String()
  	}
  	return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
  }
  
  // An UnmarshalFieldError describes a JSON object key that
  // led to an unexported (and therefore unwritable) struct field.
  // (No longer used; kept for compatibility.)
  type UnmarshalFieldError struct {
  	Key   string
  	Type  reflect.Type
  	Field reflect.StructField
  }
  
  func (e *UnmarshalFieldError) Error() string {
  	return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
  }
  
  // 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 (e *InvalidUnmarshalError) Error() string {
  	if e.Type == nil {
  		return "json: Unmarshal(nil)"
  	}
  
  	if e.Type.Kind() != reflect.Ptr {
  		return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
  	}
  	return "json: Unmarshal(nil " + e.Type.String() + ")"
  }
  
  func (d *decodeState) unmarshal(v interface{}) (err error) {
  	defer func() {
  		if r := recover(); r != nil {
  			if _, ok := r.(runtime.Error); ok {
  				panic(r)
  			}
  			err = r.(error)
  		}
  	}()
  
  	rv := reflect.ValueOf(v)
  	if rv.Kind() != reflect.Ptr || rv.IsNil() {
  		return &InvalidUnmarshalError{reflect.TypeOf(v)}
  	}
  
  	d.scan.reset()
  	// We decode rv not rv.Elem because the Unmarshaler interface
  	// test must be applied at the top level of the value.
  	d.value(rv)
  	return d.savedError
  }
  
  // A Number represents a JSON number literal.
  type Number string
  
  // String returns the literal text of the number.
  func (n Number) String() string { return string(n) }
  
  // Float64 returns the number as a float64.
  func (n Number) Float64() (float64, error) {
  	return strconv.ParseFloat(string(n), 64)
  }
  
  // Int64 returns the number as an int64.
  func (n Number) Int64() (int64, error) {
  	return strconv.ParseInt(string(n), 10, 64)
  }
  
  // isValidNumber reports whether s is a valid JSON number literal.
  func isValidNumber(s string) bool {
  	// This function implements the JSON numbers grammar.
  	// See https://tools.ietf.org/html/rfc7159#section-6
  	// and http://json.org/number.gif
  
  	if s == "" {
  		return false
  	}
  
  	// Optional -
  	if s[0] == '-' {
  		s = s[1:]
  		if s == "" {
  			return false
  		}
  	}
  
  	// Digits
  	switch {
  	default:
  		return false
  
  	case s[0] == '0':
  		s = s[1:]
  
  	case '1' <= s[0] && s[0] <= '9':
  		s = s[1:]
  		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
  			s = s[1:]
  		}
  	}
  
  	// . followed by 1 or more digits.
  	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
  		s = s[2:]
  		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
  			s = s[1:]
  		}
  	}
  
  	// e or E followed by an optional - or + and
  	// 1 or more digits.
  	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
  		s = s[1:]
  		if s[0] == '+' || s[0] == '-' {
  			s = s[1:]
  			if s == "" {
  				return false
  			}
  		}
  		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
  			s = s[1:]
  		}
  	}
  
  	// Make sure we are at the end.
  	return s == ""
  }
  
  // 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
  	errorContext struct { // provides context for type errors
  		Struct string
  		Field  string
  	}
  	savedError error
  	useNumber  bool
  }
  
  // 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 = errors.New("JSON decoder out of sync - data changing underfoot?")
  
  func (d *decodeState) init(data []byte) *decodeState {
  	d.data = data
  	d.off = 0
  	d.savedError = nil
  	d.errorContext.Struct = ""
  	d.errorContext.Field = ""
  	return d
  }
  
  // error aborts the decoding by panicking with err.
  func (d *decodeState) error(err error) {
  	panic(d.addErrorContext(err))
  }
  
  // saveError saves the first err it is called with,
  // for reporting at the end of the unmarshal.
  func (d *decodeState) saveError(err error) {
  	if d.savedError == nil {
  		d.savedError = d.addErrorContext(err)
  	}
  }
  
  // addErrorContext returns a new error enhanced with information from d.errorContext
  func (d *decodeState) addErrorContext(err error) error {
  	if d.errorContext.Struct != "" || d.errorContext.Field != "" {
  		switch err := err.(type) {
  		case *UnmarshalTypeError:
  			err.Struct = d.errorContext.Struct
  			err.Field = d.errorContext.Field
  			return err
  		}
  	}
  	return 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, ']')
  	}
  
  	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 := 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.IsValid() {
  		_, 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.redo {
  			// rewind.
  			d.scan.redo = false
  			d.scan.step = stateBeginValue
  		}
  		d.scan.step(&d.scan, '"')
  		d.scan.step(&d.scan, '"')
  
  		n := len(d.scan.parseState)
  		if n > 0 && d.scan.parseState[n-1] == parseObjectKey {
  			// d.scan thinks we just read an object key; finish the object
  			d.scan.step(&d.scan, ':')
  			d.scan.step(&d.scan, '"')
  			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)
  	}
  }
  
  type unquotedValue struct{}
  
  // valueQuoted is like value but decodes a
  // quoted string literal or literal null into an interface value.
  // If it finds anything other than a quoted string literal or null,
  // valueQuoted returns unquotedValue{}.
  func (d *decodeState) valueQuoted() interface{} {
  	switch op := d.scanWhile(scanSkipSpace); op {
  	default:
  		d.error(errPhase)
  
  	case scanBeginArray:
  		d.array(reflect.Value{})
  
  	case scanBeginObject:
  		d.object(reflect.Value{})
  
  	case scanBeginLiteral:
  		switch v := d.literalInterface().(type) {
  		case nil, string:
  			return v
  		}
  	}
  	return unquotedValue{}
  }
  
  // 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 decodingNull is true, indirect stops at the last pointer so it can be set to nil.
  func (d *decodeState) indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
  	// If v is a named type and is addressable,
  	// start with its address, so that if the type has pointer methods,
  	// we find them.
  	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
  		v = v.Addr()
  	}
  	for {
  		// Load value from interface, but only if the result will be
  		// usefully addressable.
  		if v.Kind() == reflect.Interface && !v.IsNil() {
  			e := v.Elem()
  			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
  				v = e
  				continue
  			}
  		}
  
  		if v.Kind() != reflect.Ptr {
  			break
  		}
  
  		if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
  			break
  		}
  		if v.IsNil() {
  			v.Set(reflect.New(v.Type().Elem()))
  		}
  		if v.Type().NumMethod() > 0 {
  			if u, ok := v.Interface().(Unmarshaler); ok {
  				return u, nil, reflect.Value{}
  			}
  			if !decodingNull {
  				if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
  					return nil, u, reflect.Value{}
  				}
  			}
  		}
  		v = v.Elem()
  	}
  	return nil, nil, v
  }
  
  // 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.
  	u, ut, pv := d.indirect(v, false)
  	if u != nil {
  		d.off--
  		err := u.UnmarshalJSON(d.next())
  		if err != nil {
  			d.error(err)
  		}
  		return
  	}
  	if ut != nil {
  		d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
  		d.off--
  		d.next()
  		return
  	}
  
  	v = pv
  
  	// Check type of target.
  	switch v.Kind() {
  	case reflect.Interface:
  		if v.NumMethod() == 0 {
  			// Decoding into nil interface?  Switch to non-reflect code.
  			v.Set(reflect.ValueOf(d.arrayInterface()))
  			return
  		}
  		// Otherwise it's invalid.
  		fallthrough
  	default:
  		d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
  		d.off--
  		d.next()
  		return
  	case reflect.Array:
  	case reflect.Slice:
  		break
  	}
  
  	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 v.Kind() == reflect.Slice {
  			// Grow slice if necessary
  			if i >= v.Cap() {
  				newcap := v.Cap() + v.Cap()/2
  				if newcap < 4 {
  					newcap = 4
  				}
  				newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
  				reflect.Copy(newv, v)
  				v.Set(newv)
  			}
  			if i >= v.Len() {
  				v.SetLen(i + 1)
  			}
  		}
  
  		if i < v.Len() {
  			// Decode into element.
  			d.value(v.Index(i))
  		} else {
  			// Ran out of fixed array: skip.
  			d.value(reflect.Value{})
  		}
  		i++
  
  		// Next token must be , or ].
  		op = d.scanWhile(scanSkipSpace)
  		if op == scanEndArray {
  			break
  		}
  		if op != scanArrayValue {
  			d.error(errPhase)
  		}
  	}
  
  	if i < v.Len() {
  		if v.Kind() == reflect.Array {
  			// Array. Zero the rest.
  			z := reflect.Zero(v.Type().Elem())
  			for ; i < v.Len(); i++ {
  				v.Index(i).Set(z)
  			}
  		} else {
  			v.SetLen(i)
  		}
  	}
  	if i == 0 && v.Kind() == reflect.Slice {
  		v.Set(reflect.MakeSlice(v.Type(), 0, 0))
  	}
  }
  
  var nullLiteral = []byte("null")
  var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
  
  // 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.
  	u, ut, pv := d.indirect(v, false)
  	if u != nil {
  		d.off--
  		err := u.UnmarshalJSON(d.next())
  		if err != nil {
  			d.error(err)
  		}
  		return
  	}
  	if ut != nil {
  		d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
  		d.off--
  		d.next() // skip over { } in input
  		return
  	}
  	v = pv
  
  	// Decoding into nil interface?  Switch to non-reflect code.
  	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
  		v.Set(reflect.ValueOf(d.objectInterface()))
  		return
  	}
  
  	// Check type of target:
  	//   struct or
  	//   map[T1]T2 where T1 is string, an integer type,
  	//             or an encoding.TextUnmarshaler
  	switch v.Kind() {
  	case reflect.Map:
  		// Map key must either have string kind, have an integer kind,
  		// or be an encoding.TextUnmarshaler.
  		t := v.Type()
  		switch t.Key().Kind() {
  		case reflect.String,
  			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
  			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  		default:
  			if !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) {
  				d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
  				d.off--
  				d.next() // skip over { } in input
  				return
  			}
  		}
  		if v.IsNil() {
  			v.Set(reflect.MakeMap(t))
  		}
  	case reflect.Struct:
  		// ok
  	default:
  		d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
  		d.off--
  		d.next() // skip over { } in input
  		return
  	}
  
  	var mapElem reflect.Value
  
  	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 key.
  		start := d.off - 1
  		op = d.scanWhile(scanContinue)
  		item := d.data[start : d.off-1]
  		key, ok := unquoteBytes(item)
  		if !ok {
  			d.error(errPhase)
  		}
  
  		// Figure out field corresponding to key.
  		var subv reflect.Value
  		destring := false // whether the value is wrapped in a string to be decoded first
  
  		if v.Kind() == reflect.Map {
  			elemType := v.Type().Elem()
  			if !mapElem.IsValid() {
  				mapElem = reflect.New(elemType).Elem()
  			} else {
  				mapElem.Set(reflect.Zero(elemType))
  			}
  			subv = mapElem
  		} else {
  			var f *field
  			fields := cachedTypeFields(v.Type())
  			for i := range fields {
  				ff := &fields[i]
  				if bytes.Equal(ff.nameBytes, key) {
  					f = ff
  					break
  				}
  				if f == nil && ff.equalFold(ff.nameBytes, key) {
  					f = ff
  				}
  			}
  			if f != nil {
  				subv = v
  				destring = f.quoted
  				for _, i := range f.index {
  					if subv.Kind() == reflect.Ptr {
  						if subv.IsNil() {
  							subv.Set(reflect.New(subv.Type().Elem()))
  						}
  						subv = subv.Elem()
  					}
  					subv = subv.Field(i)
  				}
  				d.errorContext.Field = f.name
  				d.errorContext.Struct = v.Type().Name()
  			}
  		}
  
  		// Read : before value.
  		if op == scanSkipSpace {
  			op = d.scanWhile(scanSkipSpace)
  		}
  		if op != scanObjectKey {
  			d.error(errPhase)
  		}
  
  		if destring {
  			switch qv := d.valueQuoted().(type) {
  			case nil:
  				d.literalStore(nullLiteral, subv, false)
  			case string:
  				d.literalStore([]byte(qv), subv, true)
  			default:
  				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
  			}
  		} else {
  			d.value(subv)
  		}
  
  		// Write value back to map;
  		// if using struct, subv points into struct already.
  		if v.Kind() == reflect.Map {
  			kt := v.Type().Key()
  			var kv reflect.Value
  			switch {
  			case kt.Kind() == reflect.String:
  				kv = reflect.ValueOf(key).Convert(kt)
  			case reflect.PtrTo(kt).Implements(textUnmarshalerType):
  				kv = reflect.New(v.Type().Key())
  				d.literalStore(item, kv, true)
  				kv = kv.Elem()
  			default:
  				switch kt.Kind() {
  				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  					s := string(key)
  					n, err := strconv.ParseInt(s, 10, 64)
  					if err != nil || reflect.Zero(kt).OverflowInt(n) {
  						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
  						return
  					}
  					kv = reflect.ValueOf(n).Convert(kt)
  				case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  					s := string(key)
  					n, err := strconv.ParseUint(s, 10, 64)
  					if err != nil || reflect.Zero(kt).OverflowUint(n) {
  						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
  						return
  					}
  					kv = reflect.ValueOf(n).Convert(kt)
  				default:
  					panic("json: Unexpected key type") // should never occur
  				}
  			}
  			v.SetMapIndex(kv, subv)
  		}
  
  		// Next token must be , or }.
  		op = d.scanWhile(scanSkipSpace)
  		if op == scanEndObject {
  			break
  		}
  		if op != scanObjectValue {
  			d.error(errPhase)
  		}
  
  		d.errorContext.Struct = ""
  		d.errorContext.Field = ""
  	}
  }
  
  // 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)
  
  	d.literalStore(d.data[start:d.off], v, false)
  }
  
  // convertNumber converts the number literal s to a float64 or a Number
  // depending on the setting of d.useNumber.
  func (d *decodeState) convertNumber(s string) (interface{}, error) {
  	if d.useNumber {
  		return Number(s), nil
  	}
  	f, err := strconv.ParseFloat(s, 64)
  	if err != nil {
  		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
  	}
  	return f, nil
  }
  
  var numberType = reflect.TypeOf(Number(""))
  
  // literalStore decodes a literal stored in item into v.
  //
  // fromQuoted indicates whether this literal came from unwrapping a
  // string from the ",string" struct tag option. this is used only to
  // produce more helpful error messages.
  func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) {
  	// Check for unmarshaler.
  	if len(item) == 0 {
  		//Empty string given
  		d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  		return
  	}
  	isNull := item[0] == 'n' // null
  	u, ut, pv := d.indirect(v, isNull)
  	if u != nil {
  		err := u.UnmarshalJSON(item)
  		if err != nil {
  			d.error(err)
  		}
  		return
  	}
  	if ut != nil {
  		if item[0] != '"' {
  			if fromQuoted {
  				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			} else {
  				var val string
  				switch item[0] {
  				case 'n':
  					val = "null"
  				case 't', 'f':
  					val = "bool"
  				default:
  					val = "number"
  				}
  				d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.off)})
  			}
  			return
  		}
  		s, ok := unquoteBytes(item)
  		if !ok {
  			if fromQuoted {
  				d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			} else {
  				d.error(errPhase)
  			}
  		}
  		err := ut.UnmarshalText(s)
  		if err != nil {
  			d.error(err)
  		}
  		return
  	}
  
  	v = pv
  
  	switch c := item[0]; c {
  	case 'n': // null
  		// The main parser checks that only true and false can reach here,
  		// but if this was a quoted string input, it could be anything.
  		if fromQuoted && string(item) != "null" {
  			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			break
  		}
  		switch v.Kind() {
  		case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
  			v.Set(reflect.Zero(v.Type()))
  			// otherwise, ignore null for primitives/string
  		}
  	case 't', 'f': // true, false
  		value := item[0] == 't'
  		// The main parser checks that only true and false can reach here,
  		// but if this was a quoted string input, it could be anything.
  		if fromQuoted && string(item) != "true" && string(item) != "false" {
  			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			break
  		}
  		switch v.Kind() {
  		default:
  			if fromQuoted {
  				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			} else {
  				d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.off)})
  			}
  		case reflect.Bool:
  			v.SetBool(value)
  		case reflect.Interface:
  			if v.NumMethod() == 0 {
  				v.Set(reflect.ValueOf(value))
  			} else {
  				d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.off)})
  			}
  		}
  
  	case '"': // string
  		s, ok := unquoteBytes(item)
  		if !ok {
  			if fromQuoted {
  				d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			} else {
  				d.error(errPhase)
  			}
  		}
  		switch v.Kind() {
  		default:
  			d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.off)})
  		case reflect.Slice:
  			if v.Type().Elem().Kind() != reflect.Uint8 {
  				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.off)})
  				break
  			}
  			b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
  			n, err := base64.StdEncoding.Decode(b, s)
  			if err != nil {
  				d.saveError(err)
  				break
  			}
  			v.SetBytes(b[:n])
  		case reflect.String:
  			v.SetString(string(s))
  		case reflect.Interface:
  			if v.NumMethod() == 0 {
  				v.Set(reflect.ValueOf(string(s)))
  			} else {
  				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.off)})
  			}
  		}
  
  	default: // number
  		if c != '-' && (c < '0' || c > '9') {
  			if fromQuoted {
  				d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			} else {
  				d.error(errPhase)
  			}
  		}
  		s := string(item)
  		switch v.Kind() {
  		default:
  			if v.Kind() == reflect.String && v.Type() == numberType {
  				v.SetString(s)
  				if !isValidNumber(s) {
  					d.error(fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item))
  				}
  				break
  			}
  			if fromQuoted {
  				d.error(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
  			} else {
  				d.error(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.off)})
  			}
  		case reflect.Interface:
  			n, err := d.convertNumber(s)
  			if err != nil {
  				d.saveError(err)
  				break
  			}
  			if v.NumMethod() != 0 {
  				d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.off)})
  				break
  			}
  			v.Set(reflect.ValueOf(n))
  
  		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  			n, err := strconv.ParseInt(s, 10, 64)
  			if err != nil || v.OverflowInt(n) {
  				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.off)})
  				break
  			}
  			v.SetInt(n)
  
  		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  			n, err := strconv.ParseUint(s, 10, 64)
  			if err != nil || v.OverflowUint(n) {
  				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.off)})
  				break
  			}
  			v.SetUint(n)
  
  		case reflect.Float32, reflect.Float64:
  			n, err := strconv.ParseFloat(s, v.Type().Bits())
  			if err != nil || v.OverflowFloat(n) {
  				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.off)})
  				break
  			}
  			v.SetFloat(n)
  		}
  	}
  }
  
  // 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)
  		panic("unreachable")
  	case scanBeginArray:
  		return d.arrayInterface()
  	case scanBeginObject:
  		return d.objectInterface()
  	case scanBeginLiteral:
  		return d.literalInterface()
  	}
  }
  
  // arrayInterface is like array but returns []interface{}.
  func (d *decodeState) arrayInterface() []interface{} {
  	var v = make([]interface{}, 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)
  
  		v = append(v, 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
  }
  
  // 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 := d.convertNumber(string(item))
  		if err != nil {
  			d.saveError(err)
  		}
  		return n
  	}
  }
  
  // getu4 decodes \uXXXX from the beginning of s, returning the hex value,
  // or it returns -1.
  func getu4(s []byte) rune {
  	if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
  		return -1
  	}
  	r, err := strconv.ParseUint(string(s[2:6]), 16, 64)
  	if err != nil {
  		return -1
  	}
  	return rune(r)
  }
  
  // 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) {
  	s, ok = unquoteBytes(s)
  	t = string(s)
  	return
  }
  
  func unquoteBytes(s []byte) (t []byte, ok bool) {
  	if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
  		return
  	}
  	s = s[1 : len(s)-1]
  
  	// Check for unusual characters. If there are none,
  	// then no unquoting is needed, so return a slice of the
  	// original bytes.
  	r := 0
  	for r < len(s) {
  		c := s[r]
  		if c == '\\' || c == '"' || c < ' ' {
  			break
  		}
  		if c < utf8.RuneSelf {
  			r++
  			continue
  		}
  		rr, size := utf8.DecodeRune(s[r:])
  		if rr == utf8.RuneError && size == 1 {
  			break
  		}
  		r += size
  	}
  	if r == len(s) {
  		return s, true
  	}
  
  	b := make([]byte, len(s)+2*utf8.UTFMax)
  	w := copy(b, s[0:r])
  	for r < len(s) {
  		// 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) {
  				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--
  				rr := getu4(s[r:])
  				if rr < 0 {
  					return
  				}
  				r += 6
  				if utf16.IsSurrogate(rr) {
  					rr1 := getu4(s[r:])
  					if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
  						// A valid pair; consume.
  						r += 6
  						w += utf8.EncodeRune(b[w:], dec)
  						break
  					}
  					// Invalid surrogate; fall back to replacement rune.
  					rr = unicode.ReplacementChar
  				}
  				w += utf8.EncodeRune(b[w:], rr)
  			}
  
  		// 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:
  			rr, size := utf8.DecodeRune(s[r:])
  			r += size
  			w += utf8.EncodeRune(b[w:], rr)
  		}
  	}
  	return b[0:w], true
  }
  

View as plain text