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

View as plain text