// 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.//// 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 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.//// 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 string-keyed 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.//// 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.//// 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 objects// 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.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} func (e *UnmarshalTypeError) Error() 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	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	return d} // error aborts the decoding by panicking with err.func (d *decodeState) error(err 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 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, ']')	} 	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 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{"array", v.Type(), 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{"array", v.Type(), 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

Lines 1–500 of 1166. Load more