Source file src/pkg/encoding/json/decode.go

     1	// Copyright 2010 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Represents JSON data structure using native Go types: booleans, floats,
     6	// strings, arrays, and maps.
     7	
     8	package json
     9	
    10	import (
    11		"encoding"
    12		"encoding/base64"
    13		"fmt"
    14		"reflect"
    15		"strconv"
    16		"strings"
    17		"unicode"
    18		"unicode/utf16"
    19		"unicode/utf8"
    20	)
    21	
    22	// Unmarshal parses the JSON-encoded data and stores the result
    23	// in the value pointed to by v. If v is nil or not a pointer,
    24	// Unmarshal returns an InvalidUnmarshalError.
    25	//
    26	// Unmarshal uses the inverse of the encodings that
    27	// Marshal uses, allocating maps, slices, and pointers as necessary,
    28	// with the following additional rules:
    29	//
    30	// To unmarshal JSON into a pointer, Unmarshal first handles the case of
    31	// the JSON being the JSON literal null. In that case, Unmarshal sets
    32	// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
    33	// the value pointed at by the pointer. If the pointer is nil, Unmarshal
    34	// allocates a new value for it to point to.
    35	//
    36	// To unmarshal JSON into a value implementing the Unmarshaler interface,
    37	// Unmarshal calls that value's UnmarshalJSON method, including
    38	// when the input is a JSON null.
    39	// Otherwise, if the value implements encoding.TextUnmarshaler
    40	// and the input is a JSON quoted string, Unmarshal calls that value's
    41	// UnmarshalText method with the unquoted form of the string.
    42	//
    43	// To unmarshal JSON into a struct, Unmarshal matches incoming object
    44	// keys to the keys used by Marshal (either the struct field name or its tag),
    45	// preferring an exact match but also accepting a case-insensitive match. By
    46	// default, object keys which don't have a corresponding struct field are
    47	// ignored (see Decoder.DisallowUnknownFields for an alternative).
    48	//
    49	// To unmarshal JSON into an interface value,
    50	// Unmarshal stores one of these in the interface value:
    51	//
    52	//	bool, for JSON booleans
    53	//	float64, for JSON numbers
    54	//	string, for JSON strings
    55	//	[]interface{}, for JSON arrays
    56	//	map[string]interface{}, for JSON objects
    57	//	nil for JSON null
    58	//
    59	// To unmarshal a JSON array into a slice, Unmarshal resets the slice length
    60	// to zero and then appends each element to the slice.
    61	// As a special case, to unmarshal an empty JSON array into a slice,
    62	// Unmarshal replaces the slice with a new empty slice.
    63	//
    64	// To unmarshal a JSON array into a Go array, Unmarshal decodes
    65	// JSON array elements into corresponding Go array elements.
    66	// If the Go array is smaller than the JSON array,
    67	// the additional JSON array elements are discarded.
    68	// If the JSON array is smaller than the Go array,
    69	// the additional Go array elements are set to zero values.
    70	//
    71	// To unmarshal a JSON object into a map, Unmarshal first establishes a map to
    72	// use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
    73	// reuses the existing map, keeping existing entries. Unmarshal then stores
    74	// key-value pairs from the JSON object into the map. The map's key type must
    75	// either be a string, an integer, or implement encoding.TextUnmarshaler.
    76	//
    77	// If a JSON value is not appropriate for a given target type,
    78	// or if a JSON number overflows the target type, Unmarshal
    79	// skips that field and completes the unmarshaling as best it can.
    80	// If no more serious errors are encountered, Unmarshal returns
    81	// an UnmarshalTypeError describing the earliest such error. In any
    82	// case, it's not guaranteed that all the remaining fields following
    83	// the problematic one will be unmarshaled into the target object.
    84	//
    85	// The JSON null value unmarshals into an interface, map, pointer, or slice
    86	// by setting that Go value to nil. Because null is often used in JSON to mean
    87	// ``not present,'' unmarshaling a JSON null into any other Go type has no effect
    88	// on the value and produces no error.
    89	//
    90	// When unmarshaling quoted strings, invalid UTF-8 or
    91	// invalid UTF-16 surrogate pairs are not treated as an error.
    92	// Instead, they are replaced by the Unicode replacement
    93	// character U+FFFD.
    94	//
    95	func Unmarshal(data []byte, v interface{}) error {
    96		// Check for well-formedness.
    97		// Avoids filling out half a data structure
    98		// before discovering a JSON syntax error.
    99		var d decodeState
   100		err := checkValid(data, &d.scan)
   101		if err != nil {
   102			return err
   103		}
   104	
   105		d.init(data)
   106		return d.unmarshal(v)
   107	}
   108	
   109	// Unmarshaler is the interface implemented by types
   110	// that can unmarshal a JSON description of themselves.
   111	// The input can be assumed to be a valid encoding of
   112	// a JSON value. UnmarshalJSON must copy the JSON data
   113	// if it wishes to retain the data after returning.
   114	//
   115	// By convention, to approximate the behavior of Unmarshal itself,
   116	// Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op.
   117	type Unmarshaler interface {
   118		UnmarshalJSON([]byte) error
   119	}
   120	
   121	// An UnmarshalTypeError describes a JSON value that was
   122	// not appropriate for a value of a specific Go type.
   123	type UnmarshalTypeError struct {
   124		Value  string       // description of JSON value - "bool", "array", "number -5"
   125		Type   reflect.Type // type of Go value it could not be assigned to
   126		Offset int64        // error occurred after reading Offset bytes
   127		Struct string       // name of the struct type containing the field
   128		Field  string       // the full path from root node to the field
   129	}
   130	
   131	func (e *UnmarshalTypeError) Error() string {
   132		if e.Struct != "" || e.Field != "" {
   133			return "json: cannot unmarshal " + e.Value + " into Go struct field " + e.Struct + "." + e.Field + " of type " + e.Type.String()
   134		}
   135		return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String()
   136	}
   137	
   138	// An UnmarshalFieldError describes a JSON object key that
   139	// led to an unexported (and therefore unwritable) struct field.
   140	//
   141	// Deprecated: No longer used; kept for compatibility.
   142	type UnmarshalFieldError struct {
   143		Key   string
   144		Type  reflect.Type
   145		Field reflect.StructField
   146	}
   147	
   148	func (e *UnmarshalFieldError) Error() string {
   149		return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
   150	}
   151	
   152	// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
   153	// (The argument to Unmarshal must be a non-nil pointer.)
   154	type InvalidUnmarshalError struct {
   155		Type reflect.Type
   156	}
   157	
   158	func (e *InvalidUnmarshalError) Error() string {
   159		if e.Type == nil {
   160			return "json: Unmarshal(nil)"
   161		}
   162	
   163		if e.Type.Kind() != reflect.Ptr {
   164			return "json: Unmarshal(non-pointer " + e.Type.String() + ")"
   165		}
   166		return "json: Unmarshal(nil " + e.Type.String() + ")"
   167	}
   168	
   169	func (d *decodeState) unmarshal(v interface{}) error {
   170		rv := reflect.ValueOf(v)
   171		if rv.Kind() != reflect.Ptr || rv.IsNil() {
   172			return &InvalidUnmarshalError{reflect.TypeOf(v)}
   173		}
   174	
   175		d.scan.reset()
   176		d.scanWhile(scanSkipSpace)
   177		// We decode rv not rv.Elem because the Unmarshaler interface
   178		// test must be applied at the top level of the value.
   179		err := d.value(rv)
   180		if err != nil {
   181			return d.addErrorContext(err)
   182		}
   183		return d.savedError
   184	}
   185	
   186	// A Number represents a JSON number literal.
   187	type Number string
   188	
   189	// String returns the literal text of the number.
   190	func (n Number) String() string { return string(n) }
   191	
   192	// Float64 returns the number as a float64.
   193	func (n Number) Float64() (float64, error) {
   194		return strconv.ParseFloat(string(n), 64)
   195	}
   196	
   197	// Int64 returns the number as an int64.
   198	func (n Number) Int64() (int64, error) {
   199		return strconv.ParseInt(string(n), 10, 64)
   200	}
   201	
   202	// isValidNumber reports whether s is a valid JSON number literal.
   203	func isValidNumber(s string) bool {
   204		// This function implements the JSON numbers grammar.
   205		// See https://tools.ietf.org/html/rfc7159#section-6
   206		// and https://json.org/number.gif
   207	
   208		if s == "" {
   209			return false
   210		}
   211	
   212		// Optional -
   213		if s[0] == '-' {
   214			s = s[1:]
   215			if s == "" {
   216				return false
   217			}
   218		}
   219	
   220		// Digits
   221		switch {
   222		default:
   223			return false
   224	
   225		case s[0] == '0':
   226			s = s[1:]
   227	
   228		case '1' <= s[0] && s[0] <= '9':
   229			s = s[1:]
   230			for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
   231				s = s[1:]
   232			}
   233		}
   234	
   235		// . followed by 1 or more digits.
   236		if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
   237			s = s[2:]
   238			for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
   239				s = s[1:]
   240			}
   241		}
   242	
   243		// e or E followed by an optional - or + and
   244		// 1 or more digits.
   245		if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
   246			s = s[1:]
   247			if s[0] == '+' || s[0] == '-' {
   248				s = s[1:]
   249				if s == "" {
   250					return false
   251				}
   252			}
   253			for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
   254				s = s[1:]
   255			}
   256		}
   257	
   258		// Make sure we are at the end.
   259		return s == ""
   260	}
   261	
   262	// decodeState represents the state while decoding a JSON value.
   263	type decodeState struct {
   264		data         []byte
   265		off          int // next read offset in data
   266		opcode       int // last read result
   267		scan         scanner
   268		errorContext struct { // provides context for type errors
   269			Struct     reflect.Type
   270			FieldStack []string
   271		}
   272		savedError            error
   273		useNumber             bool
   274		disallowUnknownFields bool
   275	}
   276	
   277	// readIndex returns the position of the last byte read.
   278	func (d *decodeState) readIndex() int {
   279		return d.off - 1
   280	}
   281	
   282	// phasePanicMsg is used as a panic message when we end up with something that
   283	// shouldn't happen. It can indicate a bug in the JSON decoder, or that
   284	// something is editing the data slice while the decoder executes.
   285	const phasePanicMsg = "JSON decoder out of sync - data changing underfoot?"
   286	
   287	func (d *decodeState) init(data []byte) *decodeState {
   288		d.data = data
   289		d.off = 0
   290		d.savedError = nil
   291		d.errorContext.Struct = nil
   292	
   293		// Reuse the allocated space for the FieldStack slice.
   294		d.errorContext.FieldStack = d.errorContext.FieldStack[:0]
   295		return d
   296	}
   297	
   298	// saveError saves the first err it is called with,
   299	// for reporting at the end of the unmarshal.
   300	func (d *decodeState) saveError(err error) {
   301		if d.savedError == nil {
   302			d.savedError = d.addErrorContext(err)
   303		}
   304	}
   305	
   306	// addErrorContext returns a new error enhanced with information from d.errorContext
   307	func (d *decodeState) addErrorContext(err error) error {
   308		if d.errorContext.Struct != nil || len(d.errorContext.FieldStack) > 0 {
   309			switch err := err.(type) {
   310			case *UnmarshalTypeError:
   311				err.Struct = d.errorContext.Struct.Name()
   312				err.Field = strings.Join(d.errorContext.FieldStack, ".")
   313				return err
   314			}
   315		}
   316		return err
   317	}
   318	
   319	// skip scans to the end of what was started.
   320	func (d *decodeState) skip() {
   321		s, data, i := &d.scan, d.data, d.off
   322		depth := len(s.parseState)
   323		for {
   324			op := s.step(s, data[i])
   325			i++
   326			if len(s.parseState) < depth {
   327				d.off = i
   328				d.opcode = op
   329				return
   330			}
   331		}
   332	}
   333	
   334	// scanNext processes the byte at d.data[d.off].
   335	func (d *decodeState) scanNext() {
   336		if d.off < len(d.data) {
   337			d.opcode = d.scan.step(&d.scan, d.data[d.off])
   338			d.off++
   339		} else {
   340			d.opcode = d.scan.eof()
   341			d.off = len(d.data) + 1 // mark processed EOF with len+1
   342		}
   343	}
   344	
   345	// scanWhile processes bytes in d.data[d.off:] until it
   346	// receives a scan code not equal to op.
   347	func (d *decodeState) scanWhile(op int) {
   348		s, data, i := &d.scan, d.data, d.off
   349		for i < len(data) {
   350			newOp := s.step(s, data[i])
   351			i++
   352			if newOp != op {
   353				d.opcode = newOp
   354				d.off = i
   355				return
   356			}
   357		}
   358	
   359		d.off = len(data) + 1 // mark processed EOF with len+1
   360		d.opcode = d.scan.eof()
   361	}
   362	
   363	// rescanLiteral is similar to scanWhile(scanContinue), but it specialises the
   364	// common case where we're decoding a literal. The decoder scans the input
   365	// twice, once for syntax errors and to check the length of the value, and the
   366	// second to perform the decoding.
   367	//
   368	// Only in the second step do we use decodeState to tokenize literals, so we
   369	// know there aren't any syntax errors. We can take advantage of that knowledge,
   370	// and scan a literal's bytes much more quickly.
   371	func (d *decodeState) rescanLiteral() {
   372		data, i := d.data, d.off
   373	Switch:
   374		switch data[i-1] {
   375		case '"': // string
   376			for ; i < len(data); i++ {
   377				switch data[i] {
   378				case '\\':
   379					i++ // escaped char
   380				case '"':
   381					i++ // tokenize the closing quote too
   382					break Switch
   383				}
   384			}
   385		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-': // number
   386			for ; i < len(data); i++ {
   387				switch data[i] {
   388				case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
   389					'.', 'e', 'E', '+', '-':
   390				default:
   391					break Switch
   392				}
   393			}
   394		case 't': // true
   395			i += len("rue")
   396		case 'f': // false
   397			i += len("alse")
   398		case 'n': // null
   399			i += len("ull")
   400		}
   401		if i < len(data) {
   402			d.opcode = stateEndValue(&d.scan, data[i])
   403		} else {
   404			d.opcode = scanEnd
   405		}
   406		d.off = i + 1
   407	}
   408	
   409	// value consumes a JSON value from d.data[d.off-1:], decoding into v, and
   410	// reads the following byte ahead. If v is invalid, the value is discarded.
   411	// The first byte of the value has been read already.
   412	func (d *decodeState) value(v reflect.Value) error {
   413		switch d.opcode {
   414		default:
   415			panic(phasePanicMsg)
   416	
   417		case scanBeginArray:
   418			if v.IsValid() {
   419				if err := d.array(v); err != nil {
   420					return err
   421				}
   422			} else {
   423				d.skip()
   424			}
   425			d.scanNext()
   426	
   427		case scanBeginObject:
   428			if v.IsValid() {
   429				if err := d.object(v); err != nil {
   430					return err
   431				}
   432			} else {
   433				d.skip()
   434			}
   435			d.scanNext()
   436	
   437		case scanBeginLiteral:
   438			// All bytes inside literal return scanContinue op code.
   439			start := d.readIndex()
   440			d.rescanLiteral()
   441	
   442			if v.IsValid() {
   443				if err := d.literalStore(d.data[start:d.readIndex()], v, false); err != nil {
   444					return err
   445				}
   446			}
   447		}
   448		return nil
   449	}
   450	
   451	type unquotedValue struct{}
   452	
   453	// valueQuoted is like value but decodes a
   454	// quoted string literal or literal null into an interface value.
   455	// If it finds anything other than a quoted string literal or null,
   456	// valueQuoted returns unquotedValue{}.
   457	func (d *decodeState) valueQuoted() interface{} {
   458		switch d.opcode {
   459		default:
   460			panic(phasePanicMsg)
   461	
   462		case scanBeginArray, scanBeginObject:
   463			d.skip()
   464			d.scanNext()
   465	
   466		case scanBeginLiteral:
   467			v := d.literalInterface()
   468			switch v.(type) {
   469			case nil, string:
   470				return v
   471			}
   472		}
   473		return unquotedValue{}
   474	}
   475	
   476	// indirect walks down v allocating pointers as needed,
   477	// until it gets to a non-pointer.
   478	// if it encounters an Unmarshaler, indirect stops and returns that.
   479	// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
   480	func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
   481		// Issue #24153 indicates that it is generally not a guaranteed property
   482		// that you may round-trip a reflect.Value by calling Value.Addr().Elem()
   483		// and expect the value to still be settable for values derived from
   484		// unexported embedded struct fields.
   485		//
   486		// The logic below effectively does this when it first addresses the value
   487		// (to satisfy possible pointer methods) and continues to dereference
   488		// subsequent pointers as necessary.
   489		//
   490		// After the first round-trip, we set v back to the original value to
   491		// preserve the original RW flags contained in reflect.Value.
   492		v0 := v
   493		haveAddr := false
   494	
   495		// If v is a named type and is addressable,
   496		// start with its address, so that if the type has pointer methods,
   497		// we find them.
   498		if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
   499			haveAddr = true
   500			v = v.Addr()
   501		}
   502		for {
   503			// Load value from interface, but only if the result will be
   504			// usefully addressable.
   505			if v.Kind() == reflect.Interface && !v.IsNil() {
   506				e := v.Elem()
   507				if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
   508					haveAddr = false
   509					v = e
   510					continue
   511				}
   512			}
   513	
   514			if v.Kind() != reflect.Ptr {
   515				break
   516			}
   517	
   518			if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
   519				break
   520			}
   521	
   522			// Prevent infinite loop if v is an interface pointing to its own address:
   523			//     var v interface{}
   524			//     v = &v
   525			if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
   526				v = v.Elem()
   527				break
   528			}
   529			if v.IsNil() {
   530				v.Set(reflect.New(v.Type().Elem()))
   531			}
   532			if v.Type().NumMethod() > 0 && v.CanInterface() {
   533				if u, ok := v.Interface().(Unmarshaler); ok {
   534					return u, nil, reflect.Value{}
   535				}
   536				if !decodingNull {
   537					if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
   538						return nil, u, reflect.Value{}
   539					}
   540				}
   541			}
   542	
   543			if haveAddr {
   544				v = v0 // restore original value after round-trip Value.Addr().Elem()
   545				haveAddr = false
   546			} else {
   547				v = v.Elem()
   548			}
   549		}
   550		return nil, nil, v
   551	}
   552	
   553	// array consumes an array from d.data[d.off-1:], decoding into v.
   554	// The first byte of the array ('[') has been read already.
   555	func (d *decodeState) array(v reflect.Value) error {
   556		// Check for unmarshaler.
   557		u, ut, pv := indirect(v, false)
   558		if u != nil {
   559			start := d.readIndex()
   560			d.skip()
   561			return u.UnmarshalJSON(d.data[start:d.off])
   562		}
   563		if ut != nil {
   564			d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
   565			d.skip()
   566			return nil
   567		}
   568		v = pv
   569	
   570		// Check type of target.
   571		switch v.Kind() {
   572		case reflect.Interface:
   573			if v.NumMethod() == 0 {
   574				// Decoding into nil interface? Switch to non-reflect code.
   575				ai := d.arrayInterface()
   576				v.Set(reflect.ValueOf(ai))
   577				return nil
   578			}
   579			// Otherwise it's invalid.
   580			fallthrough
   581		default:
   582			d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
   583			d.skip()
   584			return nil
   585		case reflect.Array, reflect.Slice:
   586			break
   587		}
   588	
   589		i := 0
   590		for {
   591			// Look ahead for ] - can only happen on first iteration.
   592			d.scanWhile(scanSkipSpace)
   593			if d.opcode == scanEndArray {
   594				break
   595			}
   596	
   597			// Get element of array, growing if necessary.
   598			if v.Kind() == reflect.Slice {
   599				// Grow slice if necessary
   600				if i >= v.Cap() {
   601					newcap := v.Cap() + v.Cap()/2
   602					if newcap < 4 {
   603						newcap = 4
   604					}
   605					newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
   606					reflect.Copy(newv, v)
   607					v.Set(newv)
   608				}
   609				if i >= v.Len() {
   610					v.SetLen(i + 1)
   611				}
   612			}
   613	
   614			if i < v.Len() {
   615				// Decode into element.
   616				if err := d.value(v.Index(i)); err != nil {
   617					return err
   618				}
   619			} else {
   620				// Ran out of fixed array: skip.
   621				if err := d.value(reflect.Value{}); err != nil {
   622					return err
   623				}
   624			}
   625			i++
   626	
   627			// Next token must be , or ].
   628			if d.opcode == scanSkipSpace {
   629				d.scanWhile(scanSkipSpace)
   630			}
   631			if d.opcode == scanEndArray {
   632				break
   633			}
   634			if d.opcode != scanArrayValue {
   635				panic(phasePanicMsg)
   636			}
   637		}
   638	
   639		if i < v.Len() {
   640			if v.Kind() == reflect.Array {
   641				// Array. Zero the rest.
   642				z := reflect.Zero(v.Type().Elem())
   643				for ; i < v.Len(); i++ {
   644					v.Index(i).Set(z)
   645				}
   646			} else {
   647				v.SetLen(i)
   648			}
   649		}
   650		if i == 0 && v.Kind() == reflect.Slice {
   651			v.Set(reflect.MakeSlice(v.Type(), 0, 0))
   652		}
   653		return nil
   654	}
   655	
   656	var nullLiteral = []byte("null")
   657	var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
   658	
   659	// object consumes an object from d.data[d.off-1:], decoding into v.
   660	// The first byte ('{') of the object has been read already.
   661	func (d *decodeState) object(v reflect.Value) error {
   662		// Check for unmarshaler.
   663		u, ut, pv := indirect(v, false)
   664		if u != nil {
   665			start := d.readIndex()
   666			d.skip()
   667			return u.UnmarshalJSON(d.data[start:d.off])
   668		}
   669		if ut != nil {
   670			d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
   671			d.skip()
   672			return nil
   673		}
   674		v = pv
   675		t := v.Type()
   676	
   677		// Decoding into nil interface? Switch to non-reflect code.
   678		if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
   679			oi := d.objectInterface()
   680			v.Set(reflect.ValueOf(oi))
   681			return nil
   682		}
   683	
   684		var fields structFields
   685	
   686		// Check type of target:
   687		//   struct or
   688		//   map[T1]T2 where T1 is string, an integer type,
   689		//             or an encoding.TextUnmarshaler
   690		switch v.Kind() {
   691		case reflect.Map:
   692			// Map key must either have string kind, have an integer kind,
   693			// or be an encoding.TextUnmarshaler.
   694			switch t.Key().Kind() {
   695			case reflect.String,
   696				reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   697				reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   698			default:
   699				if !reflect.PtrTo(t.Key()).Implements(textUnmarshalerType) {
   700					d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
   701					d.skip()
   702					return nil
   703				}
   704			}
   705			if v.IsNil() {
   706				v.Set(reflect.MakeMap(t))
   707			}
   708		case reflect.Struct:
   709			fields = cachedTypeFields(t)
   710			// ok
   711		default:
   712			d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
   713			d.skip()
   714			return nil
   715		}
   716	
   717		var mapElem reflect.Value
   718		origErrorContext := d.errorContext
   719	
   720		for {
   721			// Read opening " of string key or closing }.
   722			d.scanWhile(scanSkipSpace)
   723			if d.opcode == scanEndObject {
   724				// closing } - can only happen on first iteration.
   725				break
   726			}
   727			if d.opcode != scanBeginLiteral {
   728				panic(phasePanicMsg)
   729			}
   730	
   731			// Read key.
   732			start := d.readIndex()
   733			d.rescanLiteral()
   734			item := d.data[start:d.readIndex()]
   735			key, ok := unquoteBytes(item)
   736			if !ok {
   737				panic(phasePanicMsg)
   738			}
   739	
   740			// Figure out field corresponding to key.
   741			var subv reflect.Value
   742			destring := false // whether the value is wrapped in a string to be decoded first
   743	
   744			if v.Kind() == reflect.Map {
   745				elemType := t.Elem()
   746				if !mapElem.IsValid() {
   747					mapElem = reflect.New(elemType).Elem()
   748				} else {
   749					mapElem.Set(reflect.Zero(elemType))
   750				}
   751				subv = mapElem
   752			} else {
   753				var f *field
   754				if i, ok := fields.nameIndex[string(key)]; ok {
   755					// Found an exact name match.
   756					f = &fields.list[i]
   757				} else {
   758					// Fall back to the expensive case-insensitive
   759					// linear search.
   760					for i := range fields.list {
   761						ff := &fields.list[i]
   762						if ff.equalFold(ff.nameBytes, key) {
   763							f = ff
   764							break
   765						}
   766					}
   767				}
   768				if f != nil {
   769					subv = v
   770					destring = f.quoted
   771					for _, i := range f.index {
   772						if subv.Kind() == reflect.Ptr {
   773							if subv.IsNil() {
   774								// If a struct embeds a pointer to an unexported type,
   775								// it is not possible to set a newly allocated value
   776								// since the field is unexported.
   777								//
   778								// See https://golang.org/issue/21357
   779								if !subv.CanSet() {
   780									d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
   781									// Invalidate subv to ensure d.value(subv) skips over
   782									// the JSON value without assigning it to subv.
   783									subv = reflect.Value{}
   784									destring = false
   785									break
   786								}
   787								subv.Set(reflect.New(subv.Type().Elem()))
   788							}
   789							subv = subv.Elem()
   790						}
   791						subv = subv.Field(i)
   792					}
   793					d.errorContext.FieldStack = append(d.errorContext.FieldStack, f.name)
   794					d.errorContext.Struct = t
   795				} else if d.disallowUnknownFields {
   796					d.saveError(fmt.Errorf("json: unknown field %q", key))
   797				}
   798			}
   799	
   800			// Read : before value.
   801			if d.opcode == scanSkipSpace {
   802				d.scanWhile(scanSkipSpace)
   803			}
   804			if d.opcode != scanObjectKey {
   805				panic(phasePanicMsg)
   806			}
   807			d.scanWhile(scanSkipSpace)
   808	
   809			if destring {
   810				switch qv := d.valueQuoted().(type) {
   811				case nil:
   812					if err := d.literalStore(nullLiteral, subv, false); err != nil {
   813						return err
   814					}
   815				case string:
   816					if err := d.literalStore([]byte(qv), subv, true); err != nil {
   817						return err
   818					}
   819				default:
   820					d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
   821				}
   822			} else {
   823				if err := d.value(subv); err != nil {
   824					return err
   825				}
   826			}
   827	
   828			// Write value back to map;
   829			// if using struct, subv points into struct already.
   830			if v.Kind() == reflect.Map {
   831				kt := t.Key()
   832				var kv reflect.Value
   833				switch {
   834				case kt.Kind() == reflect.String:
   835					kv = reflect.ValueOf(key).Convert(kt)
   836				case reflect.PtrTo(kt).Implements(textUnmarshalerType):
   837					kv = reflect.New(kt)
   838					if err := d.literalStore(item, kv, true); err != nil {
   839						return err
   840					}
   841					kv = kv.Elem()
   842				default:
   843					switch kt.Kind() {
   844					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   845						s := string(key)
   846						n, err := strconv.ParseInt(s, 10, 64)
   847						if err != nil || reflect.Zero(kt).OverflowInt(n) {
   848							d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
   849							break
   850						}
   851						kv = reflect.ValueOf(n).Convert(kt)
   852					case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   853						s := string(key)
   854						n, err := strconv.ParseUint(s, 10, 64)
   855						if err != nil || reflect.Zero(kt).OverflowUint(n) {
   856							d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
   857							break
   858						}
   859						kv = reflect.ValueOf(n).Convert(kt)
   860					default:
   861						panic("json: Unexpected key type") // should never occur
   862					}
   863				}
   864				if kv.IsValid() {
   865					v.SetMapIndex(kv, subv)
   866				}
   867			}
   868	
   869			// Next token must be , or }.
   870			if d.opcode == scanSkipSpace {
   871				d.scanWhile(scanSkipSpace)
   872			}
   873			// Reset errorContext to its original state.
   874			// Keep the same underlying array for FieldStack, to reuse the
   875			// space and avoid unnecessary allocs.
   876			d.errorContext.FieldStack = d.errorContext.FieldStack[:len(origErrorContext.FieldStack)]
   877			d.errorContext.Struct = origErrorContext.Struct
   878			if d.opcode == scanEndObject {
   879				break
   880			}
   881			if d.opcode != scanObjectValue {
   882				panic(phasePanicMsg)
   883			}
   884		}
   885		return nil
   886	}
   887	
   888	// convertNumber converts the number literal s to a float64 or a Number
   889	// depending on the setting of d.useNumber.
   890	func (d *decodeState) convertNumber(s string) (interface{}, error) {
   891		if d.useNumber {
   892			return Number(s), nil
   893		}
   894		f, err := strconv.ParseFloat(s, 64)
   895		if err != nil {
   896			return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
   897		}
   898		return f, nil
   899	}
   900	
   901	var numberType = reflect.TypeOf(Number(""))
   902	
   903	// literalStore decodes a literal stored in item into v.
   904	//
   905	// fromQuoted indicates whether this literal came from unwrapping a
   906	// string from the ",string" struct tag option. this is used only to
   907	// produce more helpful error messages.
   908	func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
   909		// Check for unmarshaler.
   910		if len(item) == 0 {
   911			//Empty string given
   912			d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   913			return nil
   914		}
   915		isNull := item[0] == 'n' // null
   916		u, ut, pv := indirect(v, isNull)
   917		if u != nil {
   918			return u.UnmarshalJSON(item)
   919		}
   920		if ut != nil {
   921			if item[0] != '"' {
   922				if fromQuoted {
   923					d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   924					return nil
   925				}
   926				val := "number"
   927				switch item[0] {
   928				case 'n':
   929					val = "null"
   930				case 't', 'f':
   931					val = "bool"
   932				}
   933				d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
   934				return nil
   935			}
   936			s, ok := unquoteBytes(item)
   937			if !ok {
   938				if fromQuoted {
   939					return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
   940				}
   941				panic(phasePanicMsg)
   942			}
   943			return ut.UnmarshalText(s)
   944		}
   945	
   946		v = pv
   947	
   948		switch c := item[0]; c {
   949		case 'n': // null
   950			// The main parser checks that only true and false can reach here,
   951			// but if this was a quoted string input, it could be anything.
   952			if fromQuoted && string(item) != "null" {
   953				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   954				break
   955			}
   956			switch v.Kind() {
   957			case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
   958				v.Set(reflect.Zero(v.Type()))
   959				// otherwise, ignore null for primitives/string
   960			}
   961		case 't', 'f': // true, false
   962			value := item[0] == 't'
   963			// The main parser checks that only true and false can reach here,
   964			// but if this was a quoted string input, it could be anything.
   965			if fromQuoted && string(item) != "true" && string(item) != "false" {
   966				d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   967				break
   968			}
   969			switch v.Kind() {
   970			default:
   971				if fromQuoted {
   972					d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
   973				} else {
   974					d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
   975				}
   976			case reflect.Bool:
   977				v.SetBool(value)
   978			case reflect.Interface:
   979				if v.NumMethod() == 0 {
   980					v.Set(reflect.ValueOf(value))
   981				} else {
   982					d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
   983				}
   984			}
   985	
   986		case '"': // string
   987			s, ok := unquoteBytes(item)
   988			if !ok {
   989				if fromQuoted {
   990					return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
   991				}
   992				panic(phasePanicMsg)
   993			}
   994			switch v.Kind() {
   995			default:
   996				d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
   997			case reflect.Slice:
   998				if v.Type().Elem().Kind() != reflect.Uint8 {
   999					d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
  1000					break
  1001				}
  1002				b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
  1003				n, err := base64.StdEncoding.Decode(b, s)
  1004				if err != nil {
  1005					d.saveError(err)
  1006					break
  1007				}
  1008				v.SetBytes(b[:n])
  1009			case reflect.String:
  1010				v.SetString(string(s))
  1011			case reflect.Interface:
  1012				if v.NumMethod() == 0 {
  1013					v.Set(reflect.ValueOf(string(s)))
  1014				} else {
  1015					d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
  1016				}
  1017			}
  1018	
  1019		default: // number
  1020			if c != '-' && (c < '0' || c > '9') {
  1021				if fromQuoted {
  1022					return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
  1023				}
  1024				panic(phasePanicMsg)
  1025			}
  1026			s := string(item)
  1027			switch v.Kind() {
  1028			default:
  1029				if v.Kind() == reflect.String && v.Type() == numberType {
  1030					v.SetString(s)
  1031					if !isValidNumber(s) {
  1032						return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
  1033					}
  1034					break
  1035				}
  1036				if fromQuoted {
  1037					return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
  1038				}
  1039				d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
  1040			case reflect.Interface:
  1041				n, err := d.convertNumber(s)
  1042				if err != nil {
  1043					d.saveError(err)
  1044					break
  1045				}
  1046				if v.NumMethod() != 0 {
  1047					d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
  1048					break
  1049				}
  1050				v.Set(reflect.ValueOf(n))
  1051	
  1052			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  1053				n, err := strconv.ParseInt(s, 10, 64)
  1054				if err != nil || v.OverflowInt(n) {
  1055					d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
  1056					break
  1057				}
  1058				v.SetInt(n)
  1059	
  1060			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  1061				n, err := strconv.ParseUint(s, 10, 64)
  1062				if err != nil || v.OverflowUint(n) {
  1063					d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
  1064					break
  1065				}
  1066				v.SetUint(n)
  1067	
  1068			case reflect.Float32, reflect.Float64:
  1069				n, err := strconv.ParseFloat(s, v.Type().Bits())
  1070				if err != nil || v.OverflowFloat(n) {
  1071					d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
  1072					break
  1073				}
  1074				v.SetFloat(n)
  1075			}
  1076		}
  1077		return nil
  1078	}
  1079	
  1080	// The xxxInterface routines build up a value to be stored
  1081	// in an empty interface. They are not strictly necessary,
  1082	// but they avoid the weight of reflection in this common case.
  1083	
  1084	// valueInterface is like value but returns interface{}
  1085	func (d *decodeState) valueInterface() (val interface{}) {
  1086		switch d.opcode {
  1087		default:
  1088			panic(phasePanicMsg)
  1089		case scanBeginArray:
  1090			val = d.arrayInterface()
  1091			d.scanNext()
  1092		case scanBeginObject:
  1093			val = d.objectInterface()
  1094			d.scanNext()
  1095		case scanBeginLiteral:
  1096			val = d.literalInterface()
  1097		}
  1098		return
  1099	}
  1100	
  1101	// arrayInterface is like array but returns []interface{}.
  1102	func (d *decodeState) arrayInterface() []interface{} {
  1103		var v = make([]interface{}, 0)
  1104		for {
  1105			// Look ahead for ] - can only happen on first iteration.
  1106			d.scanWhile(scanSkipSpace)
  1107			if d.opcode == scanEndArray {
  1108				break
  1109			}
  1110	
  1111			v = append(v, d.valueInterface())
  1112	
  1113			// Next token must be , or ].
  1114			if d.opcode == scanSkipSpace {
  1115				d.scanWhile(scanSkipSpace)
  1116			}
  1117			if d.opcode == scanEndArray {
  1118				break
  1119			}
  1120			if d.opcode != scanArrayValue {
  1121				panic(phasePanicMsg)
  1122			}
  1123		}
  1124		return v
  1125	}
  1126	
  1127	// objectInterface is like object but returns map[string]interface{}.
  1128	func (d *decodeState) objectInterface() map[string]interface{} {
  1129		m := make(map[string]interface{})
  1130		for {
  1131			// Read opening " of string key or closing }.
  1132			d.scanWhile(scanSkipSpace)
  1133			if d.opcode == scanEndObject {
  1134				// closing } - can only happen on first iteration.
  1135				break
  1136			}
  1137			if d.opcode != scanBeginLiteral {
  1138				panic(phasePanicMsg)
  1139			}
  1140	
  1141			// Read string key.
  1142			start := d.readIndex()
  1143			d.rescanLiteral()
  1144			item := d.data[start:d.readIndex()]
  1145			key, ok := unquote(item)
  1146			if !ok {
  1147				panic(phasePanicMsg)
  1148			}
  1149	
  1150			// Read : before value.
  1151			if d.opcode == scanSkipSpace {
  1152				d.scanWhile(scanSkipSpace)
  1153			}
  1154			if d.opcode != scanObjectKey {
  1155				panic(phasePanicMsg)
  1156			}
  1157			d.scanWhile(scanSkipSpace)
  1158	
  1159			// Read value.
  1160			m[key] = d.valueInterface()
  1161	
  1162			// Next token must be , or }.
  1163			if d.opcode == scanSkipSpace {
  1164				d.scanWhile(scanSkipSpace)
  1165			}
  1166			if d.opcode == scanEndObject {
  1167				break
  1168			}
  1169			if d.opcode != scanObjectValue {
  1170				panic(phasePanicMsg)
  1171			}
  1172		}
  1173		return m
  1174	}
  1175	
  1176	// literalInterface consumes and returns a literal from d.data[d.off-1:] and
  1177	// it reads the following byte ahead. The first byte of the literal has been
  1178	// read already (that's how the caller knows it's a literal).
  1179	func (d *decodeState) literalInterface() interface{} {
  1180		// All bytes inside literal return scanContinue op code.
  1181		start := d.readIndex()
  1182		d.rescanLiteral()
  1183	
  1184		item := d.data[start:d.readIndex()]
  1185	
  1186		switch c := item[0]; c {
  1187		case 'n': // null
  1188			return nil
  1189	
  1190		case 't', 'f': // true, false
  1191			return c == 't'
  1192	
  1193		case '"': // string
  1194			s, ok := unquote(item)
  1195			if !ok {
  1196				panic(phasePanicMsg)
  1197			}
  1198			return s
  1199	
  1200		default: // number
  1201			if c != '-' && (c < '0' || c > '9') {
  1202				panic(phasePanicMsg)
  1203			}
  1204			n, err := d.convertNumber(string(item))
  1205			if err != nil {
  1206				d.saveError(err)
  1207			}
  1208			return n
  1209		}
  1210	}
  1211	
  1212	// getu4 decodes \uXXXX from the beginning of s, returning the hex value,
  1213	// or it returns -1.
  1214	func getu4(s []byte) rune {
  1215		if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
  1216			return -1
  1217		}
  1218		var r rune
  1219		for _, c := range s[2:6] {
  1220			switch {
  1221			case '0' <= c && c <= '9':
  1222				c = c - '0'
  1223			case 'a' <= c && c <= 'f':
  1224				c = c - 'a' + 10
  1225			case 'A' <= c && c <= 'F':
  1226				c = c - 'A' + 10
  1227			default:
  1228				return -1
  1229			}
  1230			r = r*16 + rune(c)
  1231		}
  1232		return r
  1233	}
  1234	
  1235	// unquote converts a quoted JSON string literal s into an actual string t.
  1236	// The rules are different than for Go, so cannot use strconv.Unquote.
  1237	func unquote(s []byte) (t string, ok bool) {
  1238		s, ok = unquoteBytes(s)
  1239		t = string(s)
  1240		return
  1241	}
  1242	
  1243	func unquoteBytes(s []byte) (t []byte, ok bool) {
  1244		if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
  1245			return
  1246		}
  1247		s = s[1 : len(s)-1]
  1248	
  1249		// Check for unusual characters. If there are none,
  1250		// then no unquoting is needed, so return a slice of the
  1251		// original bytes.
  1252		r := 0
  1253		for r < len(s) {
  1254			c := s[r]
  1255			if c == '\\' || c == '"' || c < ' ' {
  1256				break
  1257			}
  1258			if c < utf8.RuneSelf {
  1259				r++
  1260				continue
  1261			}
  1262			rr, size := utf8.DecodeRune(s[r:])
  1263			if rr == utf8.RuneError && size == 1 {
  1264				break
  1265			}
  1266			r += size
  1267		}
  1268		if r == len(s) {
  1269			return s, true
  1270		}
  1271	
  1272		b := make([]byte, len(s)+2*utf8.UTFMax)
  1273		w := copy(b, s[0:r])
  1274		for r < len(s) {
  1275			// Out of room? Can only happen if s is full of
  1276			// malformed UTF-8 and we're replacing each
  1277			// byte with RuneError.
  1278			if w >= len(b)-2*utf8.UTFMax {
  1279				nb := make([]byte, (len(b)+utf8.UTFMax)*2)
  1280				copy(nb, b[0:w])
  1281				b = nb
  1282			}
  1283			switch c := s[r]; {
  1284			case c == '\\':
  1285				r++
  1286				if r >= len(s) {
  1287					return
  1288				}
  1289				switch s[r] {
  1290				default:
  1291					return
  1292				case '"', '\\', '/', '\'':
  1293					b[w] = s[r]
  1294					r++
  1295					w++
  1296				case 'b':
  1297					b[w] = '\b'
  1298					r++
  1299					w++
  1300				case 'f':
  1301					b[w] = '\f'
  1302					r++
  1303					w++
  1304				case 'n':
  1305					b[w] = '\n'
  1306					r++
  1307					w++
  1308				case 'r':
  1309					b[w] = '\r'
  1310					r++
  1311					w++
  1312				case 't':
  1313					b[w] = '\t'
  1314					r++
  1315					w++
  1316				case 'u':
  1317					r--
  1318					rr := getu4(s[r:])
  1319					if rr < 0 {
  1320						return
  1321					}
  1322					r += 6
  1323					if utf16.IsSurrogate(rr) {
  1324						rr1 := getu4(s[r:])
  1325						if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
  1326							// A valid pair; consume.
  1327							r += 6
  1328							w += utf8.EncodeRune(b[w:], dec)
  1329							break
  1330						}
  1331						// Invalid surrogate; fall back to replacement rune.
  1332						rr = unicode.ReplacementChar
  1333					}
  1334					w += utf8.EncodeRune(b[w:], rr)
  1335				}
  1336	
  1337			// Quote, control characters are invalid.
  1338			case c == '"', c < ' ':
  1339				return
  1340	
  1341			// ASCII
  1342			case c < utf8.RuneSelf:
  1343				b[w] = c
  1344				r++
  1345				w++
  1346	
  1347			// Coerce to well-formed UTF-8.
  1348			default:
  1349				rr, size := utf8.DecodeRune(s[r:])
  1350				r += size
  1351				w += utf8.EncodeRune(b[w:], rr)
  1352			}
  1353		}
  1354		return b[0:w], true
  1355	}
  1356	

View as plain text